From dc00986f29599a42fc13da17d954c8d14dec9422 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 26 Jul 2017 14:20:09 +0700 Subject: [PATCH 001/160] Use godot style for property names --- godot.nimble | 2 +- godot/nim/godotmacros.nim | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/godot.nimble b/godot.nimble index 6b6f57b..712aadf 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.2.1" +version = "0.2.2" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index ee967d6..9ae1057 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -300,11 +300,11 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, cast[classNameIdent](nimPtr).propNameIdent = nimVal of ConversionResult.TypeError: let errStr = typeError(propTypeLit, $val, val.getType(), - classNameLit, propNameLit) + classNameLit, astToStr(propNameIdent)) printError(errStr) of ConversionResult.RangeError: let errStr = rangeError(propTypeLit, $val, - classNameLit, propNameLit) + classNameLit, astToStr(propNameIdent)) printError(errStr) proc getFuncIdent(obj: ptr GodotObject, methData: pointer, @@ -408,7 +408,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = let usageIdent = ident(usage) result.add(getAst( registerGodotField(classNameLit, classNameIdent, - newCStringLit($field.name.basename()), + newCStringLit(toGodotStyle($field.name.basename())), ident(field.name), newCStringLit($field.typ), field.typ, genSym(nskProc, "setFunc"), genSym(nskProc, "getFunc"), From 291e14a32a742a202f04da57d8fc3a14ca26c3bd Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 26 Jul 2017 15:29:01 +0700 Subject: [PATCH 002/160] Fix table to godot converter --- godot/nim/godotnim.nim | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index e46055b..b8dd95c 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -483,8 +483,7 @@ proc godotVariantType*(T: typedesc[Table|TableRef]): VariantType {.inline.} = VariantType.Dictionary proc toGodot*[T: Table or TableRef](t: T): Variant = - var dict: Dictionary - initDictionary(dict) + let dict = initDictionary() mixin toGodot for k, v in t.pairs(): dict[toGodot(k)] = toGodot(v) From 3a6acbbe92bc5051e4e7070c6bbd0a246cf13505 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 26 Jul 2017 17:50:36 +0700 Subject: [PATCH 003/160] Add thread enter/exit callbacks --- godot/core/godotcore.nim | 4 ++++ godot/core/strings.nim | 4 ++++ godot/nim/godotnim.nim | 14 +++++++++++++- 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/godot/core/godotcore.nim b/godot/core/godotcore.nim index 7928af0..f0a0884 100644 --- a/godot/core/godotcore.nim +++ b/godot/core/godotcore.nim @@ -285,6 +285,10 @@ proc print*(message: string) {.inline.} = let s = message.toGodotString() godotPrint(s) +proc print*(message: cstring) {.inline.} = + let s = message.toGodotString() + godotPrint(s) + template printWarning*(warn: typed) = let (filename, line) = instantiationInfo() godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint) diff --git a/godot/core/strings.nim b/godot/core/strings.nim index f4c1789..0a800ac 100644 --- a/godot/core/strings.nim +++ b/godot/core/strings.nim @@ -56,3 +56,7 @@ proc `$`*(self: GodotString): string = proc toGodotString*(s: string): GodotString {.inline.} = ## Converts the Nim string into ``GodotString`` initGodotString(result, unsafeAddr s[0], cint(s.len + 1)) + +proc toGodotString*(s: cstring): GodotString {.inline.} = + ## Converts the cstring into ``GodotString`` + initGodotString(result, s, cint(s.len + 1)) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index b8dd95c..a13be85 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -554,4 +554,16 @@ proc godot_gdnative_init(options: ptr GodotNativeInitOptions) {. proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. cdecl, exportc, dynlib.} = - deallocHeap() + deallocHeap(runFinalizers = true, allowGcAfterwards = false) + +proc godot_nativescript_thread_enter() {. + cdecl, exportc, dynlib.} = + when compileOption("threads"): + setupForeignThreadGc() + else: + print(cstring"A foreign thread is created, but app is compiled without --threads:on. Bad things will happen if Nim code is invoked from this thread.") + +proc godot_nativescript_thread_exit() {. + cdecl, exportc, dynlib.} = + when compileOption("threads"): + teardownForeignThreadGc() From 15a527d8b4158fd247a05e276939167c444bc20a Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 26 Jul 2017 10:56:53 +0700 Subject: [PATCH 004/160] Add simple example --- examples/simple/.gitignore | 5 + examples/simple/README.md | 11 + examples/simple/godot_headers/godot/array.h | 122 +++++++ examples/simple/godot_headers/godot/basis.h | 121 +++++++ examples/simple/godot_headers/godot/color.h | 96 ++++++ .../simple/godot_headers/godot/dictionary.h | 89 +++++ .../simple/godot_headers/godot/gdnative.h | 302 +++++++++++++++++ .../simple/godot_headers/godot/node_path.h | 77 +++++ examples/simple/godot_headers/godot/plane.h | 93 ++++++ .../simple/godot_headers/godot/pool_arrays.h | 316 ++++++++++++++++++ examples/simple/godot_headers/godot/quat.h | 104 ++++++ examples/simple/godot_headers/godot/rect2.h | 86 +++++ examples/simple/godot_headers/godot/rect3.h | 108 ++++++ examples/simple/godot_headers/godot/rid.h | 64 ++++ examples/simple/godot_headers/godot/string.h | 76 +++++ .../simple/godot_headers/godot/transform.h | 100 ++++++ .../simple/godot_headers/godot/transform2d.h | 99 ++++++ examples/simple/godot_headers/godot/variant.h | 201 +++++++++++ examples/simple/godot_headers/godot/vector2.h | 128 +++++++ examples/simple/godot_headers/godot/vector3.h | 135 ++++++++ .../simple/godot_headers/godot_nativescript.h | 228 +++++++++++++ examples/simple/nakefile.nim | 36 ++ examples/simple/project/default_env.tres | 99 ++++++ .../project/fonts/Roboto/RobotoRegular.tres | 5 + .../project/fonts/Roboto/ttf/LICENSE.txt | 202 +++++++++++ .../fonts/Roboto/ttf/Roboto-Regular.ttf | Bin 0 -> 171676 bytes examples/simple/project/fps_counter.tscn | 34 ++ examples/simple/project/icon.png | Bin 0 -> 3406 bytes examples/simple/project/icon.png.import | 23 ++ examples/simple/project/main.tscn | 50 +++ examples/simple/project/nimlib.tres | 12 + examples/simple/project/project.godot | 14 + examples/simple/project/scene.tscn | 48 +++ .../simple/project/scripts/FPSCounter.gdns | 9 + .../simple/project/scripts/MainPanel.gdns | 9 + .../simple/project/scripts/NimRuntime.gdns | 9 + examples/simple/src/config.nims | 43 +++ examples/simple/src/fpscounter.nim | 17 + examples/simple/src/mainpanel.nim | 18 + examples/simple/src/nim.cfg | 9 + examples/simple/src/simple.nim | 12 + examples/simple/src/simple.nimble | 34 ++ 42 files changed, 3244 insertions(+) create mode 100644 examples/simple/.gitignore create mode 100644 examples/simple/README.md create mode 100644 examples/simple/godot_headers/godot/array.h create mode 100644 examples/simple/godot_headers/godot/basis.h create mode 100644 examples/simple/godot_headers/godot/color.h create mode 100644 examples/simple/godot_headers/godot/dictionary.h create mode 100644 examples/simple/godot_headers/godot/gdnative.h create mode 100644 examples/simple/godot_headers/godot/node_path.h create mode 100644 examples/simple/godot_headers/godot/plane.h create mode 100644 examples/simple/godot_headers/godot/pool_arrays.h create mode 100644 examples/simple/godot_headers/godot/quat.h create mode 100644 examples/simple/godot_headers/godot/rect2.h create mode 100644 examples/simple/godot_headers/godot/rect3.h create mode 100644 examples/simple/godot_headers/godot/rid.h create mode 100644 examples/simple/godot_headers/godot/string.h create mode 100644 examples/simple/godot_headers/godot/transform.h create mode 100644 examples/simple/godot_headers/godot/transform2d.h create mode 100644 examples/simple/godot_headers/godot/variant.h create mode 100644 examples/simple/godot_headers/godot/vector2.h create mode 100644 examples/simple/godot_headers/godot/vector3.h create mode 100644 examples/simple/godot_headers/godot_nativescript.h create mode 100644 examples/simple/nakefile.nim create mode 100644 examples/simple/project/default_env.tres create mode 100644 examples/simple/project/fonts/Roboto/RobotoRegular.tres create mode 100755 examples/simple/project/fonts/Roboto/ttf/LICENSE.txt create mode 100755 examples/simple/project/fonts/Roboto/ttf/Roboto-Regular.ttf create mode 100644 examples/simple/project/fps_counter.tscn create mode 100644 examples/simple/project/icon.png create mode 100644 examples/simple/project/icon.png.import create mode 100644 examples/simple/project/main.tscn create mode 100644 examples/simple/project/nimlib.tres create mode 100644 examples/simple/project/project.godot create mode 100644 examples/simple/project/scene.tscn create mode 100644 examples/simple/project/scripts/FPSCounter.gdns create mode 100644 examples/simple/project/scripts/MainPanel.gdns create mode 100644 examples/simple/project/scripts/NimRuntime.gdns create mode 100644 examples/simple/src/config.nims create mode 100644 examples/simple/src/fpscounter.nim create mode 100644 examples/simple/src/mainpanel.nim create mode 100644 examples/simple/src/nim.cfg create mode 100644 examples/simple/src/simple.nim create mode 100644 examples/simple/src/simple.nimble diff --git a/examples/simple/.gitignore b/examples/simple/.gitignore new file mode 100644 index 0000000..7bb79bb --- /dev/null +++ b/examples/simple/.gitignore @@ -0,0 +1,5 @@ +/project/.import +/project/_dlls +/nakefile +/godotapi +nimcache diff --git a/examples/simple/README.md b/examples/simple/README.md new file mode 100644 index 0000000..0bb1b50 --- /dev/null +++ b/examples/simple/README.md @@ -0,0 +1,11 @@ +Simple project just to demonstrate usage of the library. + +Prerequisites: + +1. Install [nake](https://github.com/fowlmouth/nake): `nimble install nake -n`. +2. Ensure `~/.nimble/bin` is in your PATH. +3. Set `GODOT_BIN` environment varible to point to Godot executable (currently requires Godot fork - see below). + +Run `nake build` in this directory to compile for the current platform. + +**NOTE:** Currently this only works with `kingdom` branch of Godot fork: https://github.com/endragor/godot. However, there are pending PRs to make this work with Godot mainline version. \ No newline at end of file diff --git a/examples/simple/godot_headers/godot/array.h b/examples/simple/godot_headers/godot/array.h new file mode 100644 index 0000000..cbdbfbd --- /dev/null +++ b/examples/simple/godot_headers/godot/array.h @@ -0,0 +1,122 @@ +/*************************************************************************/ +/* array.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef GODOT_ARRAY_H +#define GODOT_ARRAY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_ARRAY_SIZE]; +} godot_array; +#endif + +#include "pool_arrays.h" +#include "variant.h" + +#include "gdnative.h" + +void GDAPI godot_array_new(godot_array *r_dest); +void GDAPI godot_array_new_copy(godot_array *r_dest, const godot_array *p_src); +void GDAPI godot_array_new_pool_color_array(godot_array *r_dest, const godot_pool_color_array *p_pca); +void GDAPI godot_array_new_pool_vector3_array(godot_array *r_dest, const godot_pool_vector3_array *p_pv3a); +void GDAPI godot_array_new_pool_vector2_array(godot_array *r_dest, const godot_pool_vector2_array *p_pv2a); +void GDAPI godot_array_new_pool_string_array(godot_array *r_dest, const godot_pool_string_array *p_psa); +void GDAPI godot_array_new_pool_real_array(godot_array *r_dest, const godot_pool_real_array *p_pra); +void GDAPI godot_array_new_pool_int_array(godot_array *r_dest, const godot_pool_int_array *p_pia); +void GDAPI godot_array_new_pool_byte_array(godot_array *r_dest, const godot_pool_byte_array *p_pba); + +void GDAPI godot_array_set(godot_array *p_self, const godot_int p_idx, const godot_variant *p_value); + +godot_variant GDAPI godot_array_get(const godot_array *p_self, const godot_int p_idx); + +godot_variant GDAPI *godot_array_operator_index(godot_array *p_self, const godot_int p_idx); + +void GDAPI godot_array_append(godot_array *p_self, const godot_variant *p_value); + +void GDAPI godot_array_clear(godot_array *p_self); + +godot_int GDAPI godot_array_count(const godot_array *p_self, const godot_variant *p_value); + +godot_bool GDAPI godot_array_empty(const godot_array *p_self); + +void GDAPI godot_array_erase(godot_array *p_self, const godot_variant *p_value); + +godot_variant GDAPI godot_array_front(const godot_array *p_self); + +godot_variant GDAPI godot_array_back(const godot_array *p_self); + +godot_int GDAPI godot_array_find(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from); + +godot_int GDAPI godot_array_find_last(const godot_array *p_self, const godot_variant *p_what); + +godot_bool GDAPI godot_array_has(const godot_array *p_self, const godot_variant *p_value); + +godot_int GDAPI godot_array_hash(const godot_array *p_self); + +void GDAPI godot_array_insert(godot_array *p_self, const godot_int p_pos, const godot_variant *p_value); + +void GDAPI godot_array_invert(godot_array *p_self); + +godot_variant GDAPI godot_array_pop_back(godot_array *p_self); + +godot_variant GDAPI godot_array_pop_front(godot_array *p_self); + +void GDAPI godot_array_push_back(godot_array *p_self, const godot_variant *p_value); + +void GDAPI godot_array_push_front(godot_array *p_self, const godot_variant *p_value); + +void GDAPI godot_array_remove(godot_array *p_self, const godot_int p_idx); + +void GDAPI godot_array_resize(godot_array *p_self, const godot_int p_size); + +godot_int GDAPI godot_array_rfind(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from); + +godot_int GDAPI godot_array_size(const godot_array *p_self); + +void GDAPI godot_array_sort(godot_array *p_self); + +void GDAPI godot_array_sort_custom(godot_array *p_self, godot_object *p_obj, const godot_string *p_func); + +void GDAPI godot_array_destroy(godot_array *p_self); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_ARRAY_H diff --git a/examples/simple/godot_headers/godot/basis.h b/examples/simple/godot_headers/godot/basis.h new file mode 100644 index 0000000..79b2b45 --- /dev/null +++ b/examples/simple/godot_headers/godot/basis.h @@ -0,0 +1,121 @@ +/*************************************************************************/ +/* basis.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_BASIS_H +#define GODOT_BASIS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_BASIS_SIZE 36 + +#ifndef GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_BASIS_SIZE]; +} godot_basis; +#endif + +#include "gdnative.h" +#include "quat.h" +#include "vector3.h" + +void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis); +void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi); +void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler); + +godot_string GDAPI godot_basis_as_string(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_inverse(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_transposed(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_orthonormalized(const godot_basis *p_self); + +godot_real GDAPI godot_basis_determinant(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_rotated(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi); + +godot_basis GDAPI godot_basis_scaled(const godot_basis *p_self, const godot_vector3 *p_scale); + +void GDAPI godot_basis_set_scale(godot_basis *p_self, const godot_vector3 *p_scale); + +void GDAPI godot_basis_set_rotation_euler(godot_basis *p_self, const godot_vector3 *p_euler); + +void GDAPI godot_basis_set_rotation_axis_angle(godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_angle); + +godot_vector3 GDAPI godot_basis_get_scale(const godot_basis *p_self); + +godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_self); + +godot_real GDAPI godot_basis_tdotx(const godot_basis *p_self, const godot_vector3 *p_with); + +godot_real GDAPI godot_basis_tdoty(const godot_basis *p_self, const godot_vector3 *p_with); + +godot_real GDAPI godot_basis_tdotz(const godot_basis *p_self, const godot_vector3 *p_with); + +godot_vector3 GDAPI godot_basis_xform(const godot_basis *p_self, const godot_vector3 *p_v); + +godot_vector3 GDAPI godot_basis_xform_inv(const godot_basis *p_self, const godot_vector3 *p_v); + +godot_int GDAPI godot_basis_get_orthogonal_index(const godot_basis *p_self); + +void GDAPI godot_basis_new(godot_basis *r_dest); + +void GDAPI godot_basis_new_with_euler_quat(godot_basis *r_dest, const godot_quat *p_euler); + +// p_elements is a pointer to an array of 3 (!!) vector3 +void GDAPI godot_basis_get_elements(godot_basis *p_self, godot_vector3 *p_elements); + +godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_self, const godot_int p_axis); + +void GDAPI godot_basis_set_axis(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value); + +godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_self, const godot_int p_row); + +void GDAPI godot_basis_set_row(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value); + +godot_bool GDAPI godot_basis_operator_equal(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_add(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_substract(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_multiply_vector(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_multiply_scalar(const godot_basis *p_self, const godot_real p_b); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_BASIS_H diff --git a/examples/simple/godot_headers/godot/color.h b/examples/simple/godot_headers/godot/color.h new file mode 100644 index 0000000..77e709f --- /dev/null +++ b/examples/simple/godot_headers/godot/color.h @@ -0,0 +1,96 @@ +/*************************************************************************/ +/* color.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_COLOR_H +#define GODOT_COLOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_COLOR_SIZE 16 + +#ifndef GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_COLOR_SIZE]; +} godot_color; +#endif + +#include "gdnative.h" +#include "string.h" + +void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a); +void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b); + +godot_real godot_color_get_r(const godot_color *p_self); +void godot_color_set_r(godot_color *p_self, const godot_real r); + +godot_real godot_color_get_g(const godot_color *p_self); +void godot_color_set_g(godot_color *p_self, const godot_real g); + +godot_real godot_color_get_b(const godot_color *p_self); +void godot_color_set_b(godot_color *p_self, const godot_real b); + +godot_real godot_color_get_a(const godot_color *p_self); +void godot_color_set_a(godot_color *p_self, const godot_real a); + +godot_real godot_color_get_h(const godot_color *p_self); +godot_real godot_color_get_s(const godot_color *p_self); +godot_real godot_color_get_v(const godot_color *p_self); + +godot_string GDAPI godot_color_as_string(const godot_color *p_self); + +godot_int GDAPI godot_color_to_32(const godot_color *p_self); + +godot_int GDAPI godot_color_to_ARGB32(const godot_color *p_self); + +godot_real GDAPI godot_color_gray(const godot_color *p_self); + +godot_color GDAPI godot_color_inverted(const godot_color *p_self); + +godot_color GDAPI godot_color_contrasted(const godot_color *p_self); + +godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t); + +godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over); + +godot_string GDAPI godot_color_to_html(const godot_color *p_self, const godot_bool p_with_alpha); + +godot_bool GDAPI godot_color_operator_equal(const godot_color *p_self, const godot_color *p_b); + +godot_bool GDAPI godot_color_operator_less(const godot_color *p_self, const godot_color *p_b); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_COLOR_H diff --git a/examples/simple/godot_headers/godot/dictionary.h b/examples/simple/godot_headers/godot/dictionary.h new file mode 100644 index 0000000..a08deb2 --- /dev/null +++ b/examples/simple/godot_headers/godot/dictionary.h @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* dictionary.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_DICTIONARY_H +#define GODOT_DICTIONARY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_DICTIONARY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_DICTIONARY_SIZE]; +} godot_dictionary; +#endif + +#include "array.h" +#include "gdnative.h" +#include "variant.h" + +void GDAPI godot_dictionary_new(godot_dictionary *r_dest); +void GDAPI godot_dictionary_new_copy(godot_dictionary *r_dest, const godot_dictionary *p_src); +void GDAPI godot_dictionary_destroy(godot_dictionary *p_self); + +godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_self); + +godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_self); + +void GDAPI godot_dictionary_clear(godot_dictionary *p_self); + +godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_self, const godot_variant *p_key); + +godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_self, const godot_array *p_keys); + +void GDAPI godot_dictionary_erase(godot_dictionary *p_self, const godot_variant *p_key); + +godot_int GDAPI godot_dictionary_hash(const godot_dictionary *p_self); + +godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_self); + +godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_self); + +godot_variant GDAPI godot_dictionary_get(const godot_dictionary *p_self, const godot_variant *p_key); +void GDAPI godot_dictionary_set(godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value); + +godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_self, const godot_variant *p_key); + +godot_variant GDAPI *godot_dictionary_next(const godot_dictionary *p_self, const godot_variant *p_key); + +godot_bool GDAPI godot_dictionary_operator_equal(const godot_dictionary *p_self, const godot_dictionary *p_b); + +godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_self); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_DICTIONARY_H diff --git a/examples/simple/godot_headers/godot/gdnative.h b/examples/simple/godot_headers/godot/gdnative.h new file mode 100644 index 0000000..510bf36 --- /dev/null +++ b/examples/simple/godot_headers/godot/gdnative.h @@ -0,0 +1,302 @@ +/*************************************************************************/ +/* gdnative.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_GDNATIVE_H +#define GODOT_GDNATIVE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef GDAPI_BUILT_IN +#define GDAPI_EXPORT +#endif + +#ifdef _WIN32 +#if defined(GDAPI_EXPORT) +#define GDCALLINGCONV +#define GDAPI __declspec(dllexport) GDCALLINGCONV +#else +#define GDCALLINGCONV +#define GDAPI __declspec(dllimport) GDCALLINGCONV +#endif +#elif defined(__APPLE__) +#include "TargetConditionals.h" +#if TARGET_OS_IPHONE +#define GDCALLINGCONV +#define GDAPI +#elif TARGET_OS_MAC +#define GDCALLINGCONV __attribute__((sysv_abi)) +#define GDAPI GDCALLINGCONV +#endif +#else +#define GDCALLINGCONV __attribute__((sysv_abi)) +#define GDAPI GDCALLINGCONV +#endif + +// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!! +#ifdef _WIN32 +#define GDN_EXPORT __declspec(dllexport) +#else +#define GDN_EXPORT +#endif + +#include +#include + +#define GODOT_API_VERSION 1 + +////// Error + +typedef enum { + GODOT_OK, + GODOT_FAILED, ///< Generic fail error + GODOT_ERR_UNAVAILABLE, ///< What is requested is unsupported/unavailable + GODOT_ERR_UNCONFIGURED, ///< The object being used hasnt been properly set up yet + GODOT_ERR_UNAUTHORIZED, ///< Missing credentials for requested resource + GODOT_ERR_PARAMETER_RANGE_ERROR, ///< Parameter given out of range (5) + GODOT_ERR_OUT_OF_MEMORY, ///< Out of memory + GODOT_ERR_FILE_NOT_FOUND, + GODOT_ERR_FILE_BAD_DRIVE, + GODOT_ERR_FILE_BAD_PATH, + GODOT_ERR_FILE_NO_PERMISSION, // (10) + GODOT_ERR_FILE_ALREADY_IN_USE, + GODOT_ERR_FILE_CANT_OPEN, + GODOT_ERR_FILE_CANT_WRITE, + GODOT_ERR_FILE_CANT_READ, + GODOT_ERR_FILE_UNRECOGNIZED, // (15) + GODOT_ERR_FILE_CORRUPT, + GODOT_ERR_FILE_MISSING_DEPENDENCIES, + GODOT_ERR_FILE_EOF, + GODOT_ERR_CANT_OPEN, ///< Can't open a resource/socket/file + GODOT_ERR_CANT_CREATE, // (20) + GODOT_ERR_QUERY_FAILED, + GODOT_ERR_ALREADY_IN_USE, + GODOT_ERR_LOCKED, ///< resource is locked + GODOT_ERR_TIMEOUT, + GODOT_ERR_CANT_CONNECT, // (25) + GODOT_ERR_CANT_RESOLVE, + GODOT_ERR_CONNECTION_ERROR, + GODOT_ERR_CANT_AQUIRE_RESOURCE, + GODOT_ERR_CANT_FORK, + GODOT_ERR_INVALID_DATA, ///< Data passed is invalid (30) + GODOT_ERR_INVALID_PARAMETER, ///< Parameter passed is invalid + GODOT_ERR_ALREADY_EXISTS, ///< When adding, item already exists + GODOT_ERR_DOES_NOT_EXIST, ///< When retrieving/erasing, it item does not exist + GODOT_ERR_DATABASE_CANT_READ, ///< database is full + GODOT_ERR_DATABASE_CANT_WRITE, ///< database is full (35) + GODOT_ERR_COMPILATION_FAILED, + GODOT_ERR_METHOD_NOT_FOUND, + GODOT_ERR_LINK_FAILED, + GODOT_ERR_SCRIPT_FAILED, + GODOT_ERR_CYCLIC_LINK, // (40) + GODOT_ERR_INVALID_DECLARATION, + GODOT_ERR_DUPLICATE_SYMBOL, + GODOT_ERR_PARSE_ERROR, + GODOT_ERR_BUSY, + GODOT_ERR_SKIP, // (45) + GODOT_ERR_HELP, ///< user requested help!! + GODOT_ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior. + GODOT_ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames + GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD, ///< shit happens, has never been used, though + GODOT_ERR_WTF = GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD ///< short version of the above +} godot_error; + +////// bool + +typedef bool godot_bool; + +#define GODOT_TRUE 1 +#define GODOT_FALSE 0 + +/////// int + +typedef int godot_int; + +/////// real + +typedef float godot_real; + +/////// Object (forward declared) +typedef void godot_object; + +/////// Brute force forward declarations for the rest +/* +typedef struct godot_variant godot_variant; +typedef struct godot_string godot_string; +typedef struct godot_vector2 godot_vector2; +typedef struct godot_rect2 godot_rect2; +typedef struct godot_vector3 godot_vector3; +typedef struct godot_transform2d godot_transform2d; +typedef struct godot_plane godot_plane; +typedef struct godot_quat godot_quat; +typedef struct godot_rect3 godot_rect3; +typedef struct godot_basis godot_basis; +typedef struct godot_transform godot_transform; +typedef struct godot_color godot_color; +typedef struct godot_node_path godot_node_path; +typedef struct godot_rid godot_rid; +typedef struct godot_dictionary godot_dictionary; +typedef struct godot_array godot_array; +typedef struct godot_pool_byte_array godot_pool_byte_array; +typedef struct godot_pool_int_array godot_pool_int_array; +typedef struct godot_pool_real_array godot_pool_real_array; +typedef struct godot_pool_string_array godot_pool_string_array; +typedef struct godot_pool_vector2_array godot_pool_vector2_array; +typedef struct godot_pool_vector3_array godot_pool_vector3_array; +typedef struct godot_pool_color_array godot_pool_color_array; +*/ +/////// String + +#include "string.h" + +////// Vector2 + +#include "vector2.h" + +////// Rect2 + +#include "rect2.h" + +////// Vector3 + +#include "vector3.h" + +////// Transform2D + +#include "transform2d.h" + +/////// Plane + +#include "plane.h" + +/////// Quat + +#include "quat.h" + +/////// Rect3 + +#include "rect3.h" + +/////// Basis + +#include "basis.h" + +/////// Transform + +#include "transform.h" + +/////// Color + +#include "color.h" + +/////// NodePath + +#include "node_path.h" + +/////// RID + +#include "rid.h" + +/////// Dictionary + +#include "dictionary.h" + +/////// Array + +#include "array.h" + +// single API file for Pool*Array +#include "pool_arrays.h" + +void GDAPI godot_object_destroy(godot_object *p_o); + +////// Variant + +#include "variant.h" + +////// Singleton API + +godot_object GDAPI *godot_global_get_singleton(char *p_name); // result shouldn't be freed + +////// OS API + +void GDAPI *godot_get_stack_bottom(); // returns stack bottom of the main thread + +////// MethodBind API + +typedef struct { + uint8_t _dont_touch_that[1]; // TODO +} godot_method_bind; + +godot_method_bind GDAPI *godot_method_bind_get_method(const char *p_classname, const char *p_methodname); +void GDAPI godot_method_bind_ptrcall(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret); +godot_variant GDAPI godot_method_bind_call(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error); +////// Script API + +typedef struct { + godot_bool in_editor; + uint64_t core_api_hash; + uint64_t editor_api_hash; + uint64_t no_api_hash; +} godot_gdnative_init_options; + +typedef struct { + godot_bool in_editor; +} godot_gdnative_terminate_options; + +// Calling convention? +typedef godot_object *(*godot_class_constructor)(); + +godot_class_constructor GDAPI godot_get_class_constructor(const char *p_classname); + +godot_dictionary GDAPI godot_get_global_constants(); + +////// GDNative procedure types +typedef void (*godot_gdnative_init_fn)(godot_gdnative_init_options *); +typedef void (*godot_gdnative_terminate_fn)(godot_gdnative_terminate_options *); +typedef godot_variant (*godot_gdnative_procedure_fn)(void *, godot_array *); + +////// System Functions + +//using these will help Godot track how much memory is in use in debug mode +void GDAPI *godot_alloc(int p_bytes); +void GDAPI *godot_realloc(void *p_ptr, int p_bytes); +void GDAPI godot_free(void *p_ptr); + +//print using Godot's error handler list +void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line); +void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line); +void GDAPI godot_print(const godot_string *p_message); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_C_H diff --git a/examples/simple/godot_headers/godot/node_path.h b/examples/simple/godot_headers/godot/node_path.h new file mode 100644 index 0000000..06955a0 --- /dev/null +++ b/examples/simple/godot_headers/godot/node_path.h @@ -0,0 +1,77 @@ +/*************************************************************************/ +/* node_path.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_NODE_PATH_H +#define GODOT_NODE_PATH_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_NODE_PATH_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_NODE_PATH_SIZE]; +} godot_node_path; +#endif + +#include "gdnative.h" +#include "string.h" + +void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from); +void GDAPI godot_node_path_new_copy(godot_node_path *r_dest, const godot_node_path *p_src); +void GDAPI godot_node_path_destroy(godot_node_path *p_self); + +godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_self); + +godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_self); + +godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_self); + +godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_self, const godot_int p_idx); + +godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_self); + +godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_self, const godot_int p_idx); + +godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_self); + +godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_self); + +godot_bool GDAPI godot_node_path_operator_equal(const godot_node_path *p_self, const godot_node_path *p_b); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_NODE_PATH_H diff --git a/examples/simple/godot_headers/godot/plane.h b/examples/simple/godot_headers/godot/plane.h new file mode 100644 index 0000000..e9e3b71 --- /dev/null +++ b/examples/simple/godot_headers/godot/plane.h @@ -0,0 +1,93 @@ +/*************************************************************************/ +/* plane.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_PLANE_H +#define GODOT_PLANE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_PLANE_SIZE 16 + +#ifndef GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_PLANE_SIZE]; +} godot_plane; +#endif + +#include "gdnative.h" +#include "vector3.h" + +void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d); +void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3); +void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d); + +godot_string GDAPI godot_plane_as_string(const godot_plane *p_self); + +godot_plane GDAPI godot_plane_normalized(const godot_plane *p_self); + +godot_vector3 GDAPI godot_plane_center(const godot_plane *p_self); + +godot_vector3 GDAPI godot_plane_get_any_point(const godot_plane *p_self); + +godot_bool GDAPI godot_plane_is_point_over(const godot_plane *p_self, const godot_vector3 *p_point); + +godot_real GDAPI godot_plane_distance_to(const godot_plane *p_self, const godot_vector3 *p_point); + +godot_bool GDAPI godot_plane_has_point(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon); + +godot_vector3 GDAPI godot_plane_project(const godot_plane *p_self, const godot_vector3 *p_point); + +godot_bool GDAPI godot_plane_intersect_3(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c); + +godot_bool GDAPI godot_plane_intersects_ray(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir); + +godot_bool GDAPI godot_plane_intersects_segment(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end); + +godot_plane GDAPI godot_plane_operator_neg(const godot_plane *p_self); + +godot_bool GDAPI godot_plane_operator_equal(const godot_plane *p_self, const godot_plane *p_b); + +void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_normal); + +godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self); + +godot_real GDAPI godot_plane_get_d(const godot_plane *p_self); + +void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_PLANE_H diff --git a/examples/simple/godot_headers/godot/pool_arrays.h b/examples/simple/godot_headers/godot/pool_arrays.h new file mode 100644 index 0000000..1e2916c --- /dev/null +++ b/examples/simple/godot_headers/godot/pool_arrays.h @@ -0,0 +1,316 @@ +/*************************************************************************/ +/* pool_arrays.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_POOL_ARRAYS_H +#define GODOT_POOL_ARRAYS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/////// PoolByteArray + +#define GODOT_POOL_BYTE_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_BYTE_ARRAY_SIZE]; +} godot_pool_byte_array; +#endif + +/////// PoolIntArray + +#define GODOT_POOL_INT_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_INT_ARRAY_SIZE]; +} godot_pool_int_array; +#endif + +/////// PoolRealArray + +#define GODOT_POOL_REAL_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_REAL_ARRAY_SIZE]; +} godot_pool_real_array; +#endif + +/////// PoolStringArray + +#define GODOT_POOL_STRING_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_STRING_ARRAY_SIZE]; +} godot_pool_string_array; +#endif + +/////// PoolVector2Array + +#define GODOT_POOL_VECTOR2_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_VECTOR2_ARRAY_SIZE]; +} godot_pool_vector2_array; +#endif + +/////// PoolVector3Array + +#define GODOT_POOL_VECTOR3_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_VECTOR3_ARRAY_SIZE]; +} godot_pool_vector3_array; +#endif + +/////// PoolColorArray + +#define GODOT_POOL_COLOR_ARRAY_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_POOL_COLOR_ARRAY_SIZE]; +} godot_pool_color_array; +#endif + +#include "array.h" +#include "color.h" +#include "vector2.h" +#include "vector3.h" + +#include "gdnative.h" + +// byte + +void GDAPI godot_pool_byte_array_new(godot_pool_byte_array *r_dest); +void GDAPI godot_pool_byte_array_new_copy(godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src); +void GDAPI godot_pool_byte_array_new_with_array(godot_pool_byte_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_byte_array_append(godot_pool_byte_array *p_self, const uint8_t p_data); + +void GDAPI godot_pool_byte_array_append_array(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array); + +godot_error GDAPI godot_pool_byte_array_insert(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data); + +void GDAPI godot_pool_byte_array_invert(godot_pool_byte_array *p_self); + +void GDAPI godot_pool_byte_array_push_back(godot_pool_byte_array *p_self, const uint8_t p_data); + +void GDAPI godot_pool_byte_array_remove(godot_pool_byte_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_byte_array_resize(godot_pool_byte_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_byte_array_set(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data); +uint8_t GDAPI godot_pool_byte_array_get(const godot_pool_byte_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_byte_array_size(const godot_pool_byte_array *p_self); + +void GDAPI godot_pool_byte_array_destroy(godot_pool_byte_array *p_self); + +// int + +void GDAPI godot_pool_int_array_new(godot_pool_int_array *r_dest); +void GDAPI godot_pool_int_array_new_copy(godot_pool_int_array *r_dest, const godot_pool_int_array *p_src); +void GDAPI godot_pool_int_array_new_with_array(godot_pool_int_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_int_array_append(godot_pool_int_array *p_self, const godot_int p_data); + +void GDAPI godot_pool_int_array_append_array(godot_pool_int_array *p_self, const godot_pool_int_array *p_array); + +godot_error GDAPI godot_pool_int_array_insert(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data); + +void GDAPI godot_pool_int_array_invert(godot_pool_int_array *p_self); + +void GDAPI godot_pool_int_array_push_back(godot_pool_int_array *p_self, const godot_int p_data); + +void GDAPI godot_pool_int_array_remove(godot_pool_int_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_int_array_resize(godot_pool_int_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_int_array_set(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data); +godot_int GDAPI godot_pool_int_array_get(const godot_pool_int_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_int_array_size(const godot_pool_int_array *p_self); + +void GDAPI godot_pool_int_array_destroy(godot_pool_int_array *p_self); + +// real + +void GDAPI godot_pool_real_array_new(godot_pool_real_array *r_dest); +void GDAPI godot_pool_real_array_new_copy(godot_pool_real_array *r_dest, const godot_pool_real_array *p_src); +void GDAPI godot_pool_real_array_new_with_array(godot_pool_real_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_real_array_append(godot_pool_real_array *p_self, const godot_real p_data); + +void GDAPI godot_pool_real_array_append_array(godot_pool_real_array *p_self, const godot_pool_real_array *p_array); + +godot_error GDAPI godot_pool_real_array_insert(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data); + +void GDAPI godot_pool_real_array_invert(godot_pool_real_array *p_self); + +void GDAPI godot_pool_real_array_push_back(godot_pool_real_array *p_self, const godot_real p_data); + +void GDAPI godot_pool_real_array_remove(godot_pool_real_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_real_array_resize(godot_pool_real_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_real_array_set(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data); +godot_real GDAPI godot_pool_real_array_get(const godot_pool_real_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_real_array_size(const godot_pool_real_array *p_self); + +void GDAPI godot_pool_real_array_destroy(godot_pool_real_array *p_self); + +// string + +void GDAPI godot_pool_string_array_new(godot_pool_string_array *r_dest); +void GDAPI godot_pool_string_array_new_copy(godot_pool_string_array *r_dest, const godot_pool_string_array *p_src); +void GDAPI godot_pool_string_array_new_with_array(godot_pool_string_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_string_array_append(godot_pool_string_array *p_self, const godot_string *p_data); + +void GDAPI godot_pool_string_array_append_array(godot_pool_string_array *p_self, const godot_pool_string_array *p_array); + +godot_error GDAPI godot_pool_string_array_insert(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data); + +void GDAPI godot_pool_string_array_invert(godot_pool_string_array *p_self); + +void GDAPI godot_pool_string_array_push_back(godot_pool_string_array *p_self, const godot_string *p_data); + +void GDAPI godot_pool_string_array_remove(godot_pool_string_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_string_array_resize(godot_pool_string_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_string_array_set(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data); +godot_string GDAPI godot_pool_string_array_get(const godot_pool_string_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_string_array_size(const godot_pool_string_array *p_self); + +void GDAPI godot_pool_string_array_destroy(godot_pool_string_array *p_self); + +// vector2 + +void GDAPI godot_pool_vector2_array_new(godot_pool_vector2_array *r_dest); +void GDAPI godot_pool_vector2_array_new_copy(godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src); +void GDAPI godot_pool_vector2_array_new_with_array(godot_pool_vector2_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_vector2_array_append(godot_pool_vector2_array *p_self, const godot_vector2 *p_data); + +void GDAPI godot_pool_vector2_array_append_array(godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array); + +godot_error GDAPI godot_pool_vector2_array_insert(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data); + +void GDAPI godot_pool_vector2_array_invert(godot_pool_vector2_array *p_self); + +void GDAPI godot_pool_vector2_array_push_back(godot_pool_vector2_array *p_self, const godot_vector2 *p_data); + +void GDAPI godot_pool_vector2_array_remove(godot_pool_vector2_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_vector2_array_resize(godot_pool_vector2_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_vector2_array_set(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data); +godot_vector2 GDAPI godot_pool_vector2_array_get(const godot_pool_vector2_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_vector2_array_size(const godot_pool_vector2_array *p_self); + +void GDAPI godot_pool_vector2_array_destroy(godot_pool_vector2_array *p_self); + +// vector3 + +void GDAPI godot_pool_vector3_array_new(godot_pool_vector3_array *r_dest); +void GDAPI godot_pool_vector3_array_new_copy(godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src); +void GDAPI godot_pool_vector3_array_new_with_array(godot_pool_vector3_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_vector3_array_append(godot_pool_vector3_array *p_self, const godot_vector3 *p_data); + +void GDAPI godot_pool_vector3_array_append_array(godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array); + +godot_error GDAPI godot_pool_vector3_array_insert(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data); + +void GDAPI godot_pool_vector3_array_invert(godot_pool_vector3_array *p_self); + +void GDAPI godot_pool_vector3_array_push_back(godot_pool_vector3_array *p_self, const godot_vector3 *p_data); + +void GDAPI godot_pool_vector3_array_remove(godot_pool_vector3_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_vector3_array_resize(godot_pool_vector3_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_vector3_array_set(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data); +godot_vector3 GDAPI godot_pool_vector3_array_get(const godot_pool_vector3_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_vector3_array_size(const godot_pool_vector3_array *p_self); + +void GDAPI godot_pool_vector3_array_destroy(godot_pool_vector3_array *p_self); + +// color + +void GDAPI godot_pool_color_array_new(godot_pool_color_array *r_dest); +void GDAPI godot_pool_color_array_new_copy(godot_pool_color_array *r_dest, const godot_pool_color_array *p_src); +void GDAPI godot_pool_color_array_new_with_array(godot_pool_color_array *r_dest, const godot_array *p_a); + +void GDAPI godot_pool_color_array_append(godot_pool_color_array *p_self, const godot_color *p_data); + +void GDAPI godot_pool_color_array_append_array(godot_pool_color_array *p_self, const godot_pool_color_array *p_array); + +godot_error GDAPI godot_pool_color_array_insert(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data); + +void GDAPI godot_pool_color_array_invert(godot_pool_color_array *p_self); + +void GDAPI godot_pool_color_array_push_back(godot_pool_color_array *p_self, const godot_color *p_data); + +void GDAPI godot_pool_color_array_remove(godot_pool_color_array *p_self, const godot_int p_idx); + +void GDAPI godot_pool_color_array_resize(godot_pool_color_array *p_self, const godot_int p_size); + +void GDAPI godot_pool_color_array_set(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data); +godot_color GDAPI godot_pool_color_array_get(const godot_pool_color_array *p_self, const godot_int p_idx); + +godot_int GDAPI godot_pool_color_array_size(const godot_pool_color_array *p_self); + +void GDAPI godot_pool_color_array_destroy(godot_pool_color_array *p_self); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_POOL_ARRAYS_H diff --git a/examples/simple/godot_headers/godot/quat.h b/examples/simple/godot_headers/godot/quat.h new file mode 100644 index 0000000..b86cbac --- /dev/null +++ b/examples/simple/godot_headers/godot/quat.h @@ -0,0 +1,104 @@ +/*************************************************************************/ +/* quat.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_QUAT_H +#define GODOT_QUAT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_QUAT_SIZE 16 + +#ifndef GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_QUAT_SIZE]; +} godot_quat; +#endif + +#include "gdnative.h" +#include "vector3.h" + +void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w); +void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle); + +godot_real GDAPI godot_quat_get_x(const godot_quat *p_self); +void GDAPI godot_quat_set_x(godot_quat *p_self, const godot_real val); + +godot_real GDAPI godot_quat_get_y(const godot_quat *p_self); +void GDAPI godot_quat_set_y(godot_quat *p_self, const godot_real val); + +godot_real GDAPI godot_quat_get_z(const godot_quat *p_self); +void GDAPI godot_quat_set_z(godot_quat *p_self, const godot_real val); + +godot_real GDAPI godot_quat_get_w(const godot_quat *p_self); +void GDAPI godot_quat_set_w(godot_quat *p_self, const godot_real val); + +godot_string GDAPI godot_quat_as_string(const godot_quat *p_self); + +godot_real GDAPI godot_quat_length(const godot_quat *p_self); + +godot_real GDAPI godot_quat_length_squared(const godot_quat *p_self); + +godot_quat GDAPI godot_quat_normalized(const godot_quat *p_self); + +godot_bool GDAPI godot_quat_is_normalized(const godot_quat *p_self); + +godot_quat GDAPI godot_quat_inverse(const godot_quat *p_self); + +godot_real GDAPI godot_quat_dot(const godot_quat *p_self, const godot_quat *p_b); + +godot_vector3 GDAPI godot_quat_xform(const godot_quat *p_self, const godot_vector3 *p_v); + +godot_quat GDAPI godot_quat_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t); + +godot_quat GDAPI godot_quat_slerpni(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t); + +godot_quat GDAPI godot_quat_cubic_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t); + +godot_quat GDAPI godot_quat_operator_multiply(const godot_quat *p_self, const godot_real p_b); + +godot_quat GDAPI godot_quat_operator_add(const godot_quat *p_self, const godot_quat *p_b); + +godot_quat GDAPI godot_quat_operator_substract(const godot_quat *p_self, const godot_quat *p_b); + +godot_quat GDAPI godot_quat_operator_divide(const godot_quat *p_self, const godot_real p_b); + +godot_bool GDAPI godot_quat_operator_equal(const godot_quat *p_self, const godot_quat *p_b); + +godot_quat GDAPI godot_quat_operator_neg(const godot_quat *p_self); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_QUAT_H diff --git a/examples/simple/godot_headers/godot/rect2.h b/examples/simple/godot_headers/godot/rect2.h new file mode 100644 index 0000000..7b6613d --- /dev/null +++ b/examples/simple/godot_headers/godot/rect2.h @@ -0,0 +1,86 @@ +/*************************************************************************/ +/* rect2.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_RECT2_H +#define GODOT_RECT2_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#ifndef GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED +typedef struct godot_rect2 { + uint8_t _dont_touch_that[16]; +} godot_rect2; +#endif + +#include "gdnative.h" +#include "vector2.h" + +void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size); +void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height); + +godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self); + +godot_real GDAPI godot_rect2_get_area(const godot_rect2 *p_self); + +godot_bool GDAPI godot_rect2_intersects(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_bool GDAPI godot_rect2_encloses(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_bool GDAPI godot_rect2_has_no_area(const godot_rect2 *p_self); + +godot_rect2 GDAPI godot_rect2_clip(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_rect2 GDAPI godot_rect2_merge(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_bool GDAPI godot_rect2_has_point(const godot_rect2 *p_self, const godot_vector2 *p_point); + +godot_rect2 GDAPI godot_rect2_grow(const godot_rect2 *p_self, const godot_real p_by); + +godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vector2 *p_to); + +godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_vector2 GDAPI godot_rect2_get_position(const godot_rect2 *p_self); + +godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self); + +void GDAPI godot_rect2_set_position(godot_rect2 *p_self, const godot_vector2 *p_pos); + +void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_RECT2_H diff --git a/examples/simple/godot_headers/godot/rect3.h b/examples/simple/godot_headers/godot/rect3.h new file mode 100644 index 0000000..638d89f --- /dev/null +++ b/examples/simple/godot_headers/godot/rect3.h @@ -0,0 +1,108 @@ +/*************************************************************************/ +/* rect3.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_RECT3_H +#define GODOT_RECT3_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_RECT3_SIZE 24 + +#ifndef GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_RECT3_SIZE]; +} godot_rect3; +#endif + +#include "gdnative.h" +#include "plane.h" +#include "vector3.h" + +void GDAPI godot_rect3_new(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size); + +godot_vector3 GDAPI godot_rect3_get_position(const godot_rect3 *p_self); +void GDAPI godot_rect3_set_position(const godot_rect3 *p_self, const godot_vector3 *p_v); + +godot_vector3 GDAPI godot_rect3_get_size(const godot_rect3 *p_self); +void GDAPI godot_rect3_set_size(const godot_rect3 *p_self, const godot_vector3 *p_v); + +godot_string GDAPI godot_rect3_as_string(const godot_rect3 *p_self); + +godot_real GDAPI godot_rect3_get_area(const godot_rect3 *p_self); + +godot_bool GDAPI godot_rect3_has_no_area(const godot_rect3 *p_self); + +godot_bool GDAPI godot_rect3_has_no_surface(const godot_rect3 *p_self); + +godot_bool GDAPI godot_rect3_intersects(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_bool GDAPI godot_rect3_encloses(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_rect3 GDAPI godot_rect3_merge(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_rect3 GDAPI godot_rect3_intersection(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_bool GDAPI godot_rect3_intersects_plane(const godot_rect3 *p_self, const godot_plane *p_plane); + +godot_bool GDAPI godot_rect3_intersects_segment(const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to); + +godot_bool GDAPI godot_rect3_has_point(const godot_rect3 *p_self, const godot_vector3 *p_point); + +godot_vector3 GDAPI godot_rect3_get_support(const godot_rect3 *p_self, const godot_vector3 *p_dir); + +godot_vector3 GDAPI godot_rect3_get_longest_axis(const godot_rect3 *p_self); + +godot_int GDAPI godot_rect3_get_longest_axis_index(const godot_rect3 *p_self); + +godot_real GDAPI godot_rect3_get_longest_axis_size(const godot_rect3 *p_self); + +godot_vector3 GDAPI godot_rect3_get_shortest_axis(const godot_rect3 *p_self); + +godot_int GDAPI godot_rect3_get_shortest_axis_index(const godot_rect3 *p_self); + +godot_real GDAPI godot_rect3_get_shortest_axis_size(const godot_rect3 *p_self); + +godot_rect3 GDAPI godot_rect3_expand(const godot_rect3 *p_self, const godot_vector3 *p_to_point); + +godot_rect3 GDAPI godot_rect3_grow(const godot_rect3 *p_self, const godot_real p_by); + +godot_vector3 GDAPI godot_rect3_get_endpoint(const godot_rect3 *p_self, const godot_int p_idx); + +godot_bool GDAPI godot_rect3_operator_equal(const godot_rect3 *p_self, const godot_rect3 *p_b); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_RECT3_H diff --git a/examples/simple/godot_headers/godot/rid.h b/examples/simple/godot_headers/godot/rid.h new file mode 100644 index 0000000..92e101f --- /dev/null +++ b/examples/simple/godot_headers/godot/rid.h @@ -0,0 +1,64 @@ +/*************************************************************************/ +/* rid.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_RID_H +#define GODOT_RID_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_RID_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_RID_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_RID_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_RID_SIZE]; +} godot_rid; +#endif + +#include "gdnative.h" + +void GDAPI godot_rid_new(godot_rid *r_dest); + +godot_int GDAPI godot_rid_get_id(const godot_rid *p_self); + +void GDAPI godot_rid_new_with_resource(godot_rid *r_dest, const godot_object *p_from); + +godot_bool GDAPI godot_rid_operator_equal(const godot_rid *p_self, const godot_rid *p_b); + +godot_bool GDAPI godot_rid_operator_less(const godot_rid *p_self, const godot_rid *p_b); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_RID_H diff --git a/examples/simple/godot_headers/godot/string.h b/examples/simple/godot_headers/godot/string.h new file mode 100644 index 0000000..d4d6d6c --- /dev/null +++ b/examples/simple/godot_headers/godot/string.h @@ -0,0 +1,76 @@ +/*************************************************************************/ +/* string.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_STRING_H +#define GODOT_STRING_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#define GODOT_STRING_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_STRING_SIZE]; +} godot_string; +#endif + +#include "gdnative.h" + +void GDAPI godot_string_new(godot_string *r_dest); +void GDAPI godot_string_new_copy(godot_string *r_dest, const godot_string *p_src); +void GDAPI godot_string_new_data(godot_string *r_dest, const char *p_contents, const int p_size); +void GDAPI godot_string_new_unicode_data(godot_string *r_dest, const wchar_t *p_contents, const int p_size); + +void GDAPI godot_string_get_data(const godot_string *p_self, char *p_dest, int *p_size); + +wchar_t GDAPI *godot_string_operator_index(godot_string *p_self, const godot_int p_idx); +const char GDAPI *godot_string_c_str(const godot_string *p_self); +const wchar_t GDAPI *godot_string_unicode_str(const godot_string *p_self); + +godot_bool GDAPI godot_string_operator_equal(const godot_string *p_self, const godot_string *p_b); +godot_bool GDAPI godot_string_operator_less(const godot_string *p_self, const godot_string *p_b); +godot_string GDAPI godot_string_operator_plus(const godot_string *p_self, const godot_string *p_b); + +// @Incomplete +// hmm, I guess exposing the whole API doesn't make much sense +// since the language used in the library has its own string funcs + +void GDAPI godot_string_destroy(godot_string *p_self); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_STRING_H diff --git a/examples/simple/godot_headers/godot/transform.h b/examples/simple/godot_headers/godot/transform.h new file mode 100644 index 0000000..d14190e --- /dev/null +++ b/examples/simple/godot_headers/godot/transform.h @@ -0,0 +1,100 @@ +/*************************************************************************/ +/* transform.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_TRANSFORM_H +#define GODOT_TRANSFORM_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_TRANSFORM_SIZE 48 + +#ifndef GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_TRANSFORM_SIZE]; +} godot_transform; +#endif + +#include "basis.h" +#include "gdnative.h" +#include "variant.h" +#include "vector3.h" + +void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin); +void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin); + +godot_basis GDAPI godot_transform_get_basis(const godot_transform *p_self); +void GDAPI godot_transform_set_basis(godot_transform *p_self, godot_basis *p_v); + +godot_vector3 GDAPI godot_transform_get_origin(const godot_transform *p_self); +void GDAPI godot_transform_set_origin(godot_transform *p_self, godot_vector3 *p_v); + +godot_string GDAPI godot_transform_as_string(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_inverse(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_affine_inverse(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_orthonormalized(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_rotated(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi); + +godot_transform GDAPI godot_transform_scaled(const godot_transform *p_self, const godot_vector3 *p_scale); + +godot_transform GDAPI godot_transform_translated(const godot_transform *p_self, const godot_vector3 *p_ofs); + +godot_transform GDAPI godot_transform_looking_at(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up); + +godot_plane GDAPI godot_transform_xform_plane(const godot_transform *p_self, const godot_plane *p_v); + +godot_plane GDAPI godot_transform_xform_inv_plane(const godot_transform *p_self, const godot_plane *p_v); + +void GDAPI godot_transform_new_identity(godot_transform *r_dest); + +godot_bool GDAPI godot_transform_operator_equal(const godot_transform *p_self, const godot_transform *p_b); + +godot_transform GDAPI godot_transform_operator_multiply(const godot_transform *p_self, const godot_transform *p_b); + +godot_vector3 GDAPI godot_transform_xform_vector3(const godot_transform *p_self, const godot_vector3 *p_v); + +godot_vector3 GDAPI godot_transform_xform_inv_vector3(const godot_transform *p_self, const godot_vector3 *p_v); + +godot_rect3 GDAPI godot_transform_xform_rect3(const godot_transform *p_self, const godot_rect3 *p_v); + +godot_rect3 GDAPI godot_transform_xform_inv_rect3(const godot_transform *p_self, const godot_rect3 *p_v); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_TRANSFORM_H diff --git a/examples/simple/godot_headers/godot/transform2d.h b/examples/simple/godot_headers/godot/transform2d.h new file mode 100644 index 0000000..7171e52 --- /dev/null +++ b/examples/simple/godot_headers/godot/transform2d.h @@ -0,0 +1,99 @@ +/*************************************************************************/ +/* transform2d.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_TRANSFORM2D_H +#define GODOT_TRANSFORM2D_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_TRANSFORM2D_SIZE 24 + +#ifndef GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_TRANSFORM2D_SIZE]; +} godot_transform2d; +#endif + +#include "gdnative.h" +#include "variant.h" +#include "vector2.h" + +void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos); +void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin); + +godot_string GDAPI godot_transform2d_as_string(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_affine_inverse(const godot_transform2d *p_self); + +godot_real GDAPI godot_transform2d_get_rotation(const godot_transform2d *p_self); + +godot_vector2 GDAPI godot_transform2d_get_origin(const godot_transform2d *p_self); + +godot_vector2 GDAPI godot_transform2d_get_scale(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_orthonormalized(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_rotated(const godot_transform2d *p_self, const godot_real p_phi); + +godot_transform2d GDAPI godot_transform2d_scaled(const godot_transform2d *p_self, const godot_vector2 *p_scale); + +godot_transform2d GDAPI godot_transform2d_translated(const godot_transform2d *p_self, const godot_vector2 *p_offset); + +godot_vector2 GDAPI godot_transform2d_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_vector2 GDAPI godot_transform2d_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_vector2 GDAPI godot_transform2d_basis_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_vector2 GDAPI godot_transform2d_basis_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_transform2d GDAPI godot_transform2d_interpolate_with(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c); + +godot_bool GDAPI godot_transform2d_operator_equal(const godot_transform2d *p_self, const godot_transform2d *p_b); + +godot_transform2d GDAPI godot_transform2d_operator_multiply(const godot_transform2d *p_self, const godot_transform2d *p_b); + +void GDAPI godot_transform2d_new_identity(godot_transform2d *r_dest); + +godot_rect2 GDAPI godot_transform2d_xform_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v); + +godot_rect2 GDAPI godot_transform2d_xform_inv_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_TRANSFORM2D_H diff --git a/examples/simple/godot_headers/godot/variant.h b/examples/simple/godot_headers/godot/variant.h new file mode 100644 index 0000000..b56d582 --- /dev/null +++ b/examples/simple/godot_headers/godot/variant.h @@ -0,0 +1,201 @@ +/*************************************************************************/ +/* variant.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_VARIANT_H +#define GODOT_VARIANT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_VARIANT_SIZE 24 + +#ifndef GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_VARIANT_SIZE]; +} godot_variant; +#endif + +typedef enum godot_variant_type { + GODOT_VARIANT_TYPE_NIL, + + // atomic types + GODOT_VARIANT_TYPE_BOOL, + GODOT_VARIANT_TYPE_INT, + GODOT_VARIANT_TYPE_REAL, + GODOT_VARIANT_TYPE_STRING, + + // math types + + GODOT_VARIANT_TYPE_VECTOR2, // 5 + GODOT_VARIANT_TYPE_RECT2, + GODOT_VARIANT_TYPE_VECTOR3, + GODOT_VARIANT_TYPE_TRANSFORM2D, + GODOT_VARIANT_TYPE_PLANE, + GODOT_VARIANT_TYPE_QUAT, // 10 + GODOT_VARIANT_TYPE_RECT3, + GODOT_VARIANT_TYPE_BASIS, + GODOT_VARIANT_TYPE_TRANSFORM, + + // misc types + GODOT_VARIANT_TYPE_COLOR, + GODOT_VARIANT_TYPE_NODE_PATH, // 15 + GODOT_VARIANT_TYPE_RID, + GODOT_VARIANT_TYPE_OBJECT, + GODOT_VARIANT_TYPE_DICTIONARY, + GODOT_VARIANT_TYPE_ARRAY, // 20 + + // arrays + GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY, + GODOT_VARIANT_TYPE_POOL_INT_ARRAY, + GODOT_VARIANT_TYPE_POOL_REAL_ARRAY, + GODOT_VARIANT_TYPE_POOL_STRING_ARRAY, + GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY, // 25 + GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY, + GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY, +} godot_variant_type; + +typedef enum godot_variant_call_error_error { + GODOT_CALL_ERROR_CALL_OK, + GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD, + GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT, + GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS, + GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS, + GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL, +} godot_variant_call_error_error; + +typedef struct godot_variant_call_error { + godot_variant_call_error_error error; + int argument; + godot_variant_type expected; +} godot_variant_call_error; + +#include "array.h" +#include "basis.h" +#include "color.h" +#include "dictionary.h" +#include "node_path.h" +#include "plane.h" +#include "pool_arrays.h" +#include "quat.h" +#include "rect2.h" +#include "rect3.h" +#include "rid.h" +#include "string.h" +#include "transform.h" +#include "transform2d.h" +#include "variant.h" +#include "vector2.h" +#include "vector3.h" + +#include "gdnative.h" + +godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v); + +void GDAPI godot_variant_new_copy(godot_variant *r_dest, const godot_variant *p_src); + +void GDAPI godot_variant_new_nil(godot_variant *r_dest); + +void GDAPI godot_variant_new_bool(godot_variant *p_v, const godot_bool p_b); +void GDAPI godot_variant_new_uint(godot_variant *r_dest, const uint64_t p_i); +void GDAPI godot_variant_new_int(godot_variant *r_dest, const int64_t p_i); +void GDAPI godot_variant_new_real(godot_variant *r_dest, const double p_r); +void GDAPI godot_variant_new_string(godot_variant *r_dest, const godot_string *p_s); +void GDAPI godot_variant_new_vector2(godot_variant *r_dest, const godot_vector2 *p_v2); +void GDAPI godot_variant_new_rect2(godot_variant *r_dest, const godot_rect2 *p_rect2); +void GDAPI godot_variant_new_vector3(godot_variant *r_dest, const godot_vector3 *p_v3); +void GDAPI godot_variant_new_transform2d(godot_variant *r_dest, const godot_transform2d *p_t2d); +void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_plane); +void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat); +void GDAPI godot_variant_new_rect3(godot_variant *r_dest, const godot_rect3 *p_rect3); +void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis); +void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans); +void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color); +void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np); +void GDAPI godot_variant_new_rid(godot_variant *r_dest, const godot_rid *p_rid); +void GDAPI godot_variant_new_object(godot_variant *r_dest, const godot_object *p_obj); +void GDAPI godot_variant_new_dictionary(godot_variant *r_dest, const godot_dictionary *p_dict); +void GDAPI godot_variant_new_array(godot_variant *r_dest, const godot_array *p_arr); +void GDAPI godot_variant_new_pool_byte_array(godot_variant *r_dest, const godot_pool_byte_array *p_pba); +void GDAPI godot_variant_new_pool_int_array(godot_variant *r_dest, const godot_pool_int_array *p_pia); +void GDAPI godot_variant_new_pool_real_array(godot_variant *r_dest, const godot_pool_real_array *p_pra); +void GDAPI godot_variant_new_pool_string_array(godot_variant *r_dest, const godot_pool_string_array *p_psa); +void GDAPI godot_variant_new_pool_vector2_array(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a); +void GDAPI godot_variant_new_pool_vector3_array(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a); +void GDAPI godot_variant_new_pool_color_array(godot_variant *r_dest, const godot_pool_color_array *p_pca); + +godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_self); +uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_self); +int64_t GDAPI godot_variant_as_int(const godot_variant *p_self); +double GDAPI godot_variant_as_real(const godot_variant *p_self); +godot_string GDAPI godot_variant_as_string(const godot_variant *p_self); +godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_self); +godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_self); +godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_self); +godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_self); +godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self); +godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self); +godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_self); +godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self); +godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self); +godot_color GDAPI godot_variant_as_color(const godot_variant *p_self); +godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self); +godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_self); +godot_object GDAPI *godot_variant_as_object(const godot_variant *p_self); +godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_self); +godot_array GDAPI godot_variant_as_array(const godot_variant *p_self); +godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_self); +godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_self); +godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_self); +godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_self); +godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_self); +godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_self); +godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_self); + +godot_variant GDAPI godot_variant_call(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error); + +godot_bool GDAPI godot_variant_has_method(const godot_variant *p_self, const godot_string *p_method); + +godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_self, const godot_variant *p_other); +godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_self, const godot_variant *p_other); + +godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_self, const godot_variant *p_other); + +godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_self, godot_bool *r_valid); + +void GDAPI godot_variant_destroy(godot_variant *p_self); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/examples/simple/godot_headers/godot/vector2.h b/examples/simple/godot_headers/godot/vector2.h new file mode 100644 index 0000000..9934dda --- /dev/null +++ b/examples/simple/godot_headers/godot/vector2.h @@ -0,0 +1,128 @@ +/*************************************************************************/ +/* vector2.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_VECTOR2_H +#define GODOT_VECTOR2_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_VECTOR2_SIZE 8 + +#ifndef GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_VECTOR2_SIZE]; +} godot_vector2; +#endif + +#include "gdnative.h" + +void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y); + +godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_length(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_self); + +godot_bool GDAPI godot_vector2_is_normalized(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t); + +godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t); + +godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_self, const godot_real p_phi); + +godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_self, const godot_vector2 *p_by); + +godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_self, const godot_vector2 *p_with); + +godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_self, const godot_vector2 *p_n); + +godot_vector2 GDAPI godot_vector2_bounce(const godot_vector2 *p_self, const godot_vector2 *p_n); + +godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_self, const godot_vector2 *p_n); + +godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_self, const godot_real p_length); + +godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_substract(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_self, const godot_real p_b); + +godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_self, const godot_real p_b); + +godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_neg(const godot_vector2 *p_self); + +void GDAPI godot_vector2_set_x(godot_vector2 *p_self, const godot_real p_x); + +void GDAPI godot_vector2_set_y(godot_vector2 *p_self, const godot_real p_y); + +godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_self); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_VECTOR2_H diff --git a/examples/simple/godot_headers/godot/vector3.h b/examples/simple/godot_headers/godot/vector3.h new file mode 100644 index 0000000..b5f8d0f --- /dev/null +++ b/examples/simple/godot_headers/godot/vector3.h @@ -0,0 +1,135 @@ +/*************************************************************************/ +/* vector3.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_VECTOR3_H +#define GODOT_VECTOR3_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define GODOT_VECTOR3_SIZE 12 + +#ifndef GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED +typedef struct { + uint8_t _dont_touch_that[GODOT_VECTOR3_SIZE]; +} godot_vector3; +#endif + +#include "basis.h" +#include "gdnative.h" + +typedef enum { + GODOT_VECTOR3_AXIS_X, + GODOT_VECTOR3_AXIS_Y, + GODOT_VECTOR3_AXIS_Z, +} godot_vector3_axis; + +void GDAPI godot_vector3_new(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z); + +godot_string GDAPI godot_vector3_as_string(const godot_vector3 *p_self); + +godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_self); + +godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_self); + +godot_real GDAPI godot_vector3_length(const godot_vector3 *p_self); + +godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_self); + +godot_bool GDAPI godot_vector3_is_normalized(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const godot_vector3 *p_by); + +godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi); + +godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t); + +godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t); + +godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_self); + +godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_self, const godot_vector3 *p_to); + +godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_self, const godot_vector3 *p_n); + +godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_self, const godot_vector3 *p_n); + +godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_self, const godot_vector3 *p_n); + +godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_substract(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_self, const godot_real p_b); + +godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_self, const godot_real p_b); + +godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_neg(const godot_vector3 *p_self); + +void GDAPI godot_vector3_set_axis(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val); + +godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_self, const godot_vector3_axis p_axis); + +#ifdef __cplusplus +} +#endif + +#endif // GODOT_VECTOR3_H diff --git a/examples/simple/godot_headers/godot_nativescript.h b/examples/simple/godot_headers/godot_nativescript.h new file mode 100644 index 0000000..9a84899 --- /dev/null +++ b/examples/simple/godot_headers/godot_nativescript.h @@ -0,0 +1,228 @@ +/*************************************************************************/ +/* godot.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef GODOT_NATIVESCRIPT_H +#define GODOT_NATIVESCRIPT_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef GDAPI_BUILT_IN +#define GDAPI_EXPORT +#endif + +#ifdef _WIN32 +#if defined(GDAPI_EXPORT) +#define GDCALLINGCONV +#define GDAPI __declspec(dllexport) GDCALLINGCONV +#else +#define GDCALLINGCONV +#define GDAPI __declspec(dllimport) GDCALLINGCONV +#endif +#elif defined(__APPLE__) +#include "TargetConditionals.h" +#if TARGET_OS_IPHONE +#define GDCALLINGCONV +#define GDAPI +#elif TARGET_OS_MAC +#define GDCALLINGCONV __attribute__((sysv_abi)) +#define GDAPI GDCALLINGCONV +#endif +#else +#define GDCALLINGCONV __attribute__((sysv_abi)) +#define GDAPI GDCALLINGCONV +#endif + +// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!! +#ifdef _WIN32 +#define GDN_EXPORT __declspec(dllexport) +#else +#define GDN_EXPORT +#endif + +#include +#include + +typedef enum { + GODOT_METHOD_RPC_MODE_DISABLED, + GODOT_METHOD_RPC_MODE_REMOTE, + GODOT_METHOD_RPC_MODE_SYNC, + GODOT_METHOD_RPC_MODE_MASTER, + GODOT_METHOD_RPC_MODE_SLAVE, +} godot_method_rpc_mode; + +typedef enum { + GODOT_PROPERTY_HINT_NONE, ///< no hint provided. + GODOT_PROPERTY_HINT_RANGE, ///< hint_text = "min,max,step,slider; //slider is optional" + GODOT_PROPERTY_HINT_EXP_RANGE, ///< hint_text = "min,max,step", exponential edit + GODOT_PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc" + GODOT_PROPERTY_HINT_EXP_EASING, /// exponential easing funciton (Math::ease) + GODOT_PROPERTY_HINT_LENGTH, ///< hint_text= "length" (as integer) + GODOT_PROPERTY_HINT_SPRITE_FRAME, + GODOT_PROPERTY_HINT_KEY_ACCEL, ///< hint_text= "length" (as integer) + GODOT_PROPERTY_HINT_FLAGS, ///< hint_text= "flag1,flag2,etc" (as bit flags) + GODOT_PROPERTY_HINT_LAYERS_2D_RENDER, + GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS, + GODOT_PROPERTY_HINT_LAYERS_3D_RENDER, + GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS, + GODOT_PROPERTY_HINT_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," + GODOT_PROPERTY_HINT_DIR, ///< a directort path must be passed + GODOT_PROPERTY_HINT_GLOBAL_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," + GODOT_PROPERTY_HINT_GLOBAL_DIR, ///< a directort path must be passed + GODOT_PROPERTY_HINT_RESOURCE_TYPE, ///< a resource object type + GODOT_PROPERTY_HINT_MULTILINE_TEXT, ///< used for string properties that can contain multiple lines + GODOT_PROPERTY_HINT_COLOR_NO_ALPHA, ///< used for ignoring alpha component when editing a color + GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY, + GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS, + GODOT_PROPERTY_HINT_OBJECT_ID, + GODOT_PROPERTY_HINT_TYPE_STRING, ///< a type string, the hint is the base type to choose + GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE, ///< so something else can provide this (used in scripts) + GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE, ///< a method of a type + GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE, ///< a method of a base type + GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE, ///< a method of an instance + GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT, ///< a method of a script & base + GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE, ///< a property of a type + GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE, ///< a property of a base type + GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE, ///< a property of an instance + GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT, ///< a property of a script & base + GODOT_PROPERTY_HINT_MAX, +} godot_property_hint; + +typedef enum { + + GODOT_PROPERTY_USAGE_STORAGE = 1, + GODOT_PROPERTY_USAGE_EDITOR = 2, + GODOT_PROPERTY_USAGE_NETWORK = 4, + GODOT_PROPERTY_USAGE_EDITOR_HELPER = 8, + GODOT_PROPERTY_USAGE_CHECKABLE = 16, //used for editing global variables + GODOT_PROPERTY_USAGE_CHECKED = 32, //used for editing global variables + GODOT_PROPERTY_USAGE_INTERNATIONALIZED = 64, //hint for internationalized strings + GODOT_PROPERTY_USAGE_GROUP = 128, //used for grouping props in the editor + GODOT_PROPERTY_USAGE_CATEGORY = 256, + GODOT_PROPERTY_USAGE_STORE_IF_NONZERO = 512, //only store if nonzero + GODOT_PROPERTY_USAGE_STORE_IF_NONONE = 1024, //only store if false + GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE = 2048, + GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED = 4096, + GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE = 8192, + GODOT_PROPERTY_USAGE_STORE_IF_NULL = 16384, + GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER = 32768, + GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 65536, + + GODOT_PROPERTY_USAGE_DEFAULT = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK, + GODOT_PROPERTY_USAGE_DEFAULT_INTL = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK | GODOT_PROPERTY_USAGE_INTERNATIONALIZED, + GODOT_PROPERTY_USAGE_NOEDITOR = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_NETWORK, +} godot_property_usage_flags; + +typedef struct { + godot_method_rpc_mode rset_type; + + godot_int type; + godot_property_hint hint; + godot_string hint_string; + godot_property_usage_flags usage; + godot_variant default_value; +} godot_property_attributes; + +typedef struct { + // instance pointer, method_data - return user data + GDCALLINGCONV void *(*create_func)(godot_object *, void *); + void *method_data; + GDCALLINGCONV void (*free_func)(void *); +} godot_instance_create_func; + +typedef struct { + // instance pointer, method data, user data + GDCALLINGCONV void (*destroy_func)(godot_object *, void *, void *); + void *method_data; + GDCALLINGCONV void (*free_func)(void *); +} godot_instance_destroy_func; + +void GDAPI godot_nativescript_register_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func); + +void GDAPI godot_nativescript_register_tool_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func); + +typedef struct { + godot_method_rpc_mode rpc_type; +} godot_method_attributes; + +typedef struct { + // instance pointer, method data, user data, num args, args - return result as varaint + GDCALLINGCONV godot_variant (*method)(godot_object *, void *, void *, int, godot_variant **); + void *method_data; + GDCALLINGCONV void (*free_func)(void *); +} godot_instance_method; + +void GDAPI godot_nativescript_register_method(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method); + +typedef struct { + // instance pointer, method data, user data, value + GDCALLINGCONV void (*set_func)(godot_object *, void *, void *, godot_variant *); + void *method_data; + GDCALLINGCONV void (*free_func)(void *); +} godot_property_set_func; + +typedef struct { + // instance pointer, method data, user data, value + GDCALLINGCONV godot_variant (*get_func)(godot_object *, void *, void *); + void *method_data; + GDCALLINGCONV void (*free_func)(void *); +} godot_property_get_func; + +void GDAPI godot_nativescript_register_property(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func); + +typedef struct { + godot_string name; + godot_int type; + godot_property_hint hint; + godot_string hint_string; + godot_property_usage_flags usage; + godot_variant default_value; +} godot_signal_argument; + +typedef struct { + godot_string name; + int num_args; + godot_signal_argument *args; + int num_default_args; + godot_variant *default_args; +} godot_signal; + +void GDAPI godot_nativescript_register_signal(void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal); +godot_object GDAPI *godot_nativescript_new(const char *p_classname); + +void GDAPI *godot_nativescript_get_userdata(godot_object *p_instance); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/examples/simple/nakefile.nim b/examples/simple/nakefile.nim new file mode 100644 index 0000000..0efcef7 --- /dev/null +++ b/examples/simple/nakefile.nim @@ -0,0 +1,36 @@ +# Copyright 2017 Xored Software, Inc. + +import nake +import os, ospaths, times +import apigen.apigen + +proc cmdParams(): string = + let params = commandLineParams() + assert(params.len > 0) + result = params[1.. jsonFile.getLastModificationTime(): + direShell(godotBin, "--gdnative-generate-json-api", jsonFile) + if not fileExists(jsonFile): + echo "Failed to generate api.json" + quit(-1) + + genApi(targetDir, jsonFile) + +task "build", "Builds the client for the current platform": + genGodotApi() + withDir "src": + direShell("nimble", "make") diff --git a/examples/simple/project/default_env.tres b/examples/simple/project/default_env.tres new file mode 100644 index 0000000..a22ed59 --- /dev/null +++ b/examples/simple/project/default_env.tres @@ -0,0 +1,99 @@ +[gd_resource type="Environment" load_steps=2 format=2] + +[sub_resource type="ProceduralSky" id=1] + +radiance_size = 4 +sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 ) +sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 ) +sky_curve = 0.25 +sky_energy = 1.0 +ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 ) +ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 ) +ground_curve = 0.01 +ground_energy = 1.0 +sun_color = Color( 1, 1, 1, 1 ) +sun_latitude = 35.0 +sun_longitude = 0.0 +sun_angle_min = 1.0 +sun_angle_max = 100.0 +sun_curve = 0.05 +sun_energy = 16.0 +texture_size = 2 + +[resource] + +background_mode = 2 +background_sky = SubResource( 1 ) +background_sky_scale = 1.0 +background_color = Color( 0, 0, 0, 1 ) +background_energy = 1.0 +background_canvas_max_layer = 0 +ambient_light_color = Color( 0, 0, 0, 1 ) +ambient_light_energy = 1.0 +ambient_light_sky_contribution = 0.0 +fog_enabled = false +fog_color = Color( 0.5, 0.6, 0.7, 1 ) +fog_sun_color = Color( 1, 0.9, 0.7, 1 ) +fog_sun_amount = 0.0 +fog_depth_enabled = true +fog_depth_begin = 10.0 +fog_depth_curve = 1.0 +fog_transmit_enabled = false +fog_transmit_curve = 1.0 +fog_height_enabled = false +fog_height_min = 0.0 +fog_height_max = 100.0 +fog_height_curve = 1.0 +tonemap_mode = 0 +tonemap_exposure = 1.0 +tonemap_white = 1.0 +auto_exposure_enabled = false +auto_exposure_scale = 0.4 +auto_exposure_min_luma = 0.05 +auto_exposure_max_luma = 8.0 +auto_exposure_speed = 0.5 +ss_reflections_enabled = false +ss_reflections_max_steps = 64 +ss_reflections_fade_in = 0.15 +ss_reflections_fade_out = 2.0 +ss_reflections_depth_tolerance = 0.2 +ss_reflections_roughness = true +ssao_enabled = false +ssao_radius = 1.0 +ssao_intensity = 1.0 +ssao_radius2 = 0.0 +ssao_intensity2 = 1.0 +ssao_bias = 0.01 +ssao_light_affect = 0.0 +ssao_color = Color( 0, 0, 0, 1 ) +ssao_blur = true +dof_blur_far_enabled = false +dof_blur_far_distance = 10.0 +dof_blur_far_transition = 5.0 +dof_blur_far_amount = 0.1 +dof_blur_far_quality = 1 +dof_blur_near_enabled = false +dof_blur_near_distance = 2.0 +dof_blur_near_transition = 1.0 +dof_blur_near_amount = 0.1 +dof_blur_near_quality = 1 +glow_enabled = false +glow_levels/1 = false +glow_levels/2 = false +glow_levels/3 = true +glow_levels/4 = false +glow_levels/5 = true +glow_levels/6 = false +glow_levels/7 = false +glow_intensity = 0.8 +glow_strength = 1.0 +glow_bloom = 0.0 +glow_blend_mode = 2 +glow_hdr_threshold = 1.0 +glow_hdr_scale = 2.0 +glow_bicubic_upscale = false +adjustment_enabled = false +adjustment_brightness = 1.0 +adjustment_contrast = 1.0 +adjustment_saturation = 1.0 + diff --git a/examples/simple/project/fonts/Roboto/RobotoRegular.tres b/examples/simple/project/fonts/Roboto/RobotoRegular.tres new file mode 100644 index 0000000..a1126e5 --- /dev/null +++ b/examples/simple/project/fonts/Roboto/RobotoRegular.tres @@ -0,0 +1,5 @@ +[gd_resource type="DynamicFontData" format=2] + +[resource] + +font_path = "res://fonts/Roboto/ttf/Roboto-Regular.ttf" diff --git a/examples/simple/project/fonts/Roboto/ttf/LICENSE.txt b/examples/simple/project/fonts/Roboto/ttf/LICENSE.txt new file mode 100755 index 0000000..75b5248 --- /dev/null +++ b/examples/simple/project/fonts/Roboto/ttf/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/examples/simple/project/fonts/Roboto/ttf/Roboto-Regular.ttf b/examples/simple/project/fonts/Roboto/ttf/Roboto-Regular.ttf new file mode 100755 index 0000000000000000000000000000000000000000..2c97eeadffe1a34bd67d3ff1c3887fd53e22c2ca GIT binary patch literal 171676 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 ZcAgz$Pp~K2ZnnEU$(~HkLK9l*e*jr~ZsGs{ literal 0 HcmV?d00001 diff --git a/examples/simple/project/fps_counter.tscn b/examples/simple/project/fps_counter.tscn new file mode 100644 index 0000000..67fc001 --- /dev/null +++ b/examples/simple/project/fps_counter.tscn @@ -0,0 +1,34 @@ +[gd_scene load_steps=4 format=2] + +[ext_resource path="res://fonts/Roboto/RobotoRegular.tres" type="DynamicFontData" id=1] +[ext_resource path="res://scripts/FPSCounter.gdns" type="Script" id=2] + +[sub_resource type="DynamicFont" id=1] + +size = 40 +use_mipmaps = false +use_filter = false +font_data = ExtResource( 1 ) +_sections_unfolded = [ "Extra Spacing", "Font", "Settings" ] + +[node name="Label" type="Label"] + +anchor_left = 1 +anchor_right = 1 +margin_top = 10.0 +margin_right = 10.0 +grow_horizontal = 0 +rect_pivot_offset = Vector2( 0, 0 ) +rect_clip_content = false +mouse_filter = 2 +size_flags_horizontal = 1 +size_flags_vertical = 4 +custom_fonts/font = SubResource( 1 ) +text = "FPS: 9000" +percent_visible = 1.0 +lines_skipped = 0 +max_lines_visible = -1 +script = ExtResource( 2 ) +_sections_unfolded = [ "Anchor", "Grow Direction", "Margin", "custom_colors", "custom_fonts" ] + + diff --git a/examples/simple/project/icon.png b/examples/simple/project/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..21a097a7fcde1bd609bc1e258b59242a6a4bf7a7 GIT binary patch literal 3406 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 literal 0 HcmV?d00001 diff --git a/examples/simple/project/icon.png.import b/examples/simple/project/icon.png.import new file mode 100644 index 0000000..627820b --- /dev/null +++ b/examples/simple/project/icon.png.import @@ -0,0 +1,23 @@ +[remap] + +importer="texture" +type="StreamTexture" +path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" + +[params] + +compress/mode=0 +compress/lossy_quality=0.7 +compress/hdr_mode=0 +compress/normal_map=0 +flags/repeat=0 +flags/filter=true +flags/mipmaps=false +flags/anisotropic=false +flags/srgb=2 +process/fix_alpha_border=true +process/premult_alpha=false +process/HDR_as_SRGB=false +stream=false +size_limit=0 +detect_3d=true diff --git a/examples/simple/project/main.tscn b/examples/simple/project/main.tscn new file mode 100644 index 0000000..7e4e390 --- /dev/null +++ b/examples/simple/project/main.tscn @@ -0,0 +1,50 @@ +[gd_scene load_steps=5 format=2] + +[ext_resource path="res://scripts/MainPanel.gdns" type="Script" id=1] +[ext_resource path="res://fonts/Roboto/RobotoRegular.tres" type="DynamicFontData" id=2] +[ext_resource path="res://fps_counter.tscn" type="PackedScene" id=3] + +[sub_resource type="DynamicFont" id=1] + +size = 80 +use_mipmaps = false +use_filter = false +font_data = ExtResource( 2 ) +_sections_unfolded = [ "Font", "Settings" ] + +[node name="Panel" type="Panel"] + +anchor_right = 1 +anchor_bottom = 1 +rect_pivot_offset = Vector2( 0, 0 ) +rect_clip_content = false +mouse_filter = 0 +size_flags_horizontal = 1 +size_flags_vertical = 1 +script = ExtResource( 1 ) +_sections_unfolded = [ "Anchor", "Margin" ] + +[node name="Label" type="Label" parent="."] + +anchor_right = 1 +anchor_bottom = 1 +rect_pivot_offset = Vector2( 0, 0 ) +rect_clip_content = false +mouse_filter = 2 +size_flags_horizontal = 1 +size_flags_vertical = 4 +custom_fonts/font = SubResource( 1 ) +text = "Click me to load scene" +align = 1 +valign = 1 +percent_visible = 1.0 +lines_skipped = 0 +max_lines_visible = -1 +_sections_unfolded = [ "Anchor", "Margin", "custom_fonts" ] + +[node name="FPS" parent="." instance=ExtResource( 3 )] + +margin_left = 189.0 +margin_bottom = 58.0 + + diff --git a/examples/simple/project/nimlib.tres b/examples/simple/project/nimlib.tres new file mode 100644 index 0000000..f95a4f3 --- /dev/null +++ b/examples/simple/project/nimlib.tres @@ -0,0 +1,12 @@ +[gd_resource type="GDNativeLibrary" format=2] + +[resource] + +platform/X11_32bit = "res://_dlls/nim_linux_32.so" +platform/X11_64bit = "res://_dlls/nim_linux_64.so" +platform/Windows_32bit = "res://_dlls/nim_32.dll" +platform/Windows_64bit = "res://_dlls/nim_64.dll" +platform/OSX = "res://_dlls/nim_mac.dylib" +platform/Android = "res://_dlls/nim_android.so" +platform/iOS = "res://_dlls/nim_ios.dylib" +platform/WebAssembly = "" diff --git a/examples/simple/project/project.godot b/examples/simple/project/project.godot new file mode 100644 index 0000000..009f1e5 --- /dev/null +++ b/examples/simple/project/project.godot @@ -0,0 +1,14 @@ +config_version=3 +[application] + +config/name="Simple Sample" +run/main_scene="res://main.tscn" +config/icon="res://icon.png" + +[autoload] + +NimRuntime="*res://scripts/NimRuntime.gdns" + +[rendering] + +environment/default_environment="res://default_env.tres" diff --git a/examples/simple/project/scene.tscn b/examples/simple/project/scene.tscn new file mode 100644 index 0000000..07b4429 --- /dev/null +++ b/examples/simple/project/scene.tscn @@ -0,0 +1,48 @@ +[gd_scene load_steps=3 format=2] + +[ext_resource path="res://fps_counter.tscn" type="PackedScene" id=1] + +[sub_resource type="CapsuleMesh" id=1] + +radius = 1.0 +mid_height = 1.0 +radial_segments = 64 +rings = 8 + +[node name="Node" type="Node"] + +[node name="MeshInstance" type="MeshInstance" parent="."] + +layers = 1 +material_override = null +cast_shadow = 1 +extra_cull_margin = 0.0 +visible_in_all_rooms = false +use_in_baked_light = false +lod_min_distance = 0.0 +lod_min_hysteresis = 0.0 +lod_max_distance = 0.0 +lod_max_hysteresis = 0.0 +mesh = SubResource( 1 ) +skeleton = NodePath("..") +material/0 = null +_sections_unfolded = [ "Geometry", "material" ] + +[node name="Label" parent="." instance=ExtResource( 1 )] + +[node name="Camera" type="Camera" parent="."] + +transform = Transform( 0.930689, 0.16529, -0.326338, 0, 0.892097, 0.451845, 0.365811, -0.420527, 0.830265, -0.972205, 1.19673, 2.59579 ) +projection = 0 +fov = 65.0 +near = 0.1 +far = 100.0 +keep_aspect = 1 +current = true +cull_mask = 1048575 +environment = null +h_offset = 0.0 +v_offset = 0.0 +doppler/tracking = 0 + + diff --git a/examples/simple/project/scripts/FPSCounter.gdns b/examples/simple/project/scripts/FPSCounter.gdns new file mode 100644 index 0000000..bae69db --- /dev/null +++ b/examples/simple/project/scripts/FPSCounter.gdns @@ -0,0 +1,9 @@ +[gd_resource type="NativeScript" load_steps=2 format=2] + +[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1] + +[resource] + +resource_name = "FPSCounter" +library = ExtResource( 1 ) +class_name = "FPSCounter" \ No newline at end of file diff --git a/examples/simple/project/scripts/MainPanel.gdns b/examples/simple/project/scripts/MainPanel.gdns new file mode 100644 index 0000000..4458a47 --- /dev/null +++ b/examples/simple/project/scripts/MainPanel.gdns @@ -0,0 +1,9 @@ +[gd_resource type="NativeScript" load_steps=2 format=2] + +[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1] + +[resource] + +resource_name = "MainPanel" +library = ExtResource( 1 ) +class_name = "MainPanel" \ No newline at end of file diff --git a/examples/simple/project/scripts/NimRuntime.gdns b/examples/simple/project/scripts/NimRuntime.gdns new file mode 100644 index 0000000..34656e9 --- /dev/null +++ b/examples/simple/project/scripts/NimRuntime.gdns @@ -0,0 +1,9 @@ +[gd_resource type="NativeScript" load_steps=2 format=2] + +[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1] + +[resource] + +resource_name = "NimRuntime" +library = ExtResource( 1 ) +class_name = "NimRuntime" \ No newline at end of file diff --git a/examples/simple/src/config.nims b/examples/simple/src/config.nims new file mode 100644 index 0000000..1f1cdf3 --- /dev/null +++ b/examples/simple/src/config.nims @@ -0,0 +1,43 @@ +import ospaths + +switch("nimcache", "nimcache"/hostOS/hostCPU) + +when defined(macosx): + switch("passL", "-framework Cocoa -Wl,-undefined,dynamic_lookup") +elif defined(android): + let ndk = getEnv("ANDROID_NDK_ROOT") + let toolchain = getEnv("ANDROID_TOOLCHAIN") + + if ndk.len == 0: + raise newException(OSError, + "ANDROID_NDK_ROOT environment variable is necessary for android build") + if toolchain.len == 0: + raise newException(OSError, + "ANDROID_TOOLCHAIN environment variable is necessary for android build") + + const level = $16 # change this to the necessary API level + const arch = "arm" + let sysroot = "--sysroot=\"" & ndk & "/platforms/android-" & level & "/arch-" & arch & "/\"" + switch("passL", sysroot) + switch("passC", sysroot) + + switch("cc", "clang") + switch("arm.linux.clang.path", toolchain / "bin") + switch("arm.linux.clang.exe", arch & "-linux-androideabi-clang") + switch("arm.linux.clang.compilerexe", arch & "-linux-androideabi-clang") + switch("arm.linux.clang.linkerexe", arch & "-linux-androideabi-clang") +elif defined(windows): + assert(sizeof(int) == 8) + switch("cc", "vcc") + let godotLib = getEnv("GODOT_LIB") + if godotLib.len == 0: + raise newException(OSError, + "GODOT_LIB must be specified and point to the .lib file") + switch("clib", godotLib.changeFileExt("")) +elif defined(linux): + switch("passC", "-fPIC") +else: + raise newException(OSError, "Unsupported platform: " & hostOS) + +when not defined(release): + switch("debugger", "native") diff --git a/examples/simple/src/fpscounter.nim b/examples/simple/src/fpscounter.nim new file mode 100644 index 0000000..2227513 --- /dev/null +++ b/examples/simple/src/fpscounter.nim @@ -0,0 +1,17 @@ +# Copyright 2017 Xored Software, Inc. + +import strutils +import godot +import engine, label, resource_loader, packed_scene + +gdobj FPSCounter of Label: + var lastFPS: float32 + + method ready*() = + setProcess(true) + + method process*(delta: float64) = + let fps = getFramesPerSecond() + if int(fps * 10) != int(lastFPS * 10): + lastFPS = fps + self.text = "FPS: " & formatFloat(fps, ffDecimal, 1) diff --git a/examples/simple/src/mainpanel.nim b/examples/simple/src/mainpanel.nim new file mode 100644 index 0000000..8f6c16e --- /dev/null +++ b/examples/simple/src/mainpanel.nim @@ -0,0 +1,18 @@ +# Copyright 2017 Xored Software, Inc. + +import godot +import scene_tree, resource_loader, packed_scene, panel, global_constants, + input_event_mouse_button + +gdobj MainPanel of Panel: + method ready*() = + setProcessInput(true) + + method input*(event: InputEvent) = + if event of InputEventMouseButton: + let ev = event as InputEventMouseButton + if ev.buttonIndex == BUTTON_LEFT: + getTree().setInputAsHandled() + let scene = load("res://scene.tscn") as PackedScene + getTree().getRoot().addChild(scene.instance()) + queueFree() diff --git a/examples/simple/src/nim.cfg b/examples/simple/src/nim.cfg new file mode 100644 index 0000000..7e8f842 --- /dev/null +++ b/examples/simple/src/nim.cfg @@ -0,0 +1,9 @@ +--path:"$projectdir" +--path:"$projectdir/../godotapi" +--cincludes:"$projectdir/../godot_headers/" +--experimental +--app:lib +--stackTrace:on +-d:useRealtimeGc +--noMain +--warning[LockLevel]:off \ No newline at end of file diff --git a/examples/simple/src/simple.nim b/examples/simple/src/simple.nim new file mode 100644 index 0000000..5e725b8 --- /dev/null +++ b/examples/simple/src/simple.nim @@ -0,0 +1,12 @@ +# Copyright 2017 Xored Software, Inc. + +## Import independent scene objects here +## (no need to import everything, just independent roots) + +when not defined(release): + import segfaults # converts segfaults into NilAccessError + +import nimruntime + +import fpscounter +import mainpanel diff --git a/examples/simple/src/simple.nimble b/examples/simple/src/simple.nimble new file mode 100644 index 0000000..43a4780 --- /dev/null +++ b/examples/simple/src/simple.nimble @@ -0,0 +1,34 @@ +version = "0.1.0" +author = "Xored Software, Inc." +description = "FPS Counter Sample" +license = "MIT" +bin = @["simple"] + +requires "https://github.com/pragmagic/godot-nim.git >= 0.2.2 & < 0.3.0" + +task make, "build": + const archPostfix = when sizeof(int) == 8: "_64" else: "_32" + const libFile = + when defined(windows): + "nim" & archPostfix & ".dll" + elif defined(ios): + "nim_ios.dylib" + elif defined(macosx): + "nim_mac.dylib" + elif defined(android): + "nim_android.so" + elif defined(linux): + "nim_linux" & archPostfix & ".so" + else: nil + if libFile.isNil: + raise newException(OSError, "Unsupported platform") + + exec "nimble build -y" + const dir = "../project/_dlls/" + const target = dir & libFile + mkDir(dir) + when defined(windows): + rmFile(target) + mvFile(bin[0] & ".exe", target) + else: + mvFile(bin[0], target) From b023775f792980562246b8f3e6a91ef81b28a335 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 26 Jul 2017 21:23:14 +0700 Subject: [PATCH 005/160] Add install godot-nim step to instruction --- examples/simple/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/simple/README.md b/examples/simple/README.md index 0bb1b50..9eb7cb4 100644 --- a/examples/simple/README.md +++ b/examples/simple/README.md @@ -5,6 +5,7 @@ Prerequisites: 1. Install [nake](https://github.com/fowlmouth/nake): `nimble install nake -n`. 2. Ensure `~/.nimble/bin` is in your PATH. 3. Set `GODOT_BIN` environment varible to point to Godot executable (currently requires Godot fork - see below). +4. Install godot-nim: `nimble install https://github.com/pragmagic/godot-nim.git` (needed for nakefile) Run `nake build` in this directory to compile for the current platform. From 863df0ae454b8614c2145474cca717a5301a871d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 26 Jul 2017 22:50:10 +0700 Subject: [PATCH 006/160] Proper handling of References --- godot/nim/godotmacros.nim | 43 ++++++++++++++++++++++++++++++++------- godot/nim/godotnim.nim | 20 +++++++++++++----- 2 files changed, 51 insertions(+), 12 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 9ae1057..4ab140c 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -264,16 +264,29 @@ proc rangeError(nimType: cstring, value: string, className: cstring, proc nimDestroyFunc(obj: ptr GodotObject, methData: pointer, userData: pointer) {.noconv.} = - let nimObj = cast[ref NimGodotObject](userData) + let nimObj = cast[NimGodotObject](userData) nimObj.removeGodotObject() GC_unref(nimObj) -template registerGodotClass(classNameIdent, classNameLit, +proc nimDestroyRefFunc(obj: ptr GodotObject, methData: pointer, + userData: pointer) {.noconv.} = + # references are destroyed by Godot when they are already destroyed by Nim, + # so nothing to do here. + discard + +proc refcountIncremented*(obj: NimGodotObject) = + GC_ref(obj) + +proc refcountDecremented*(obj: NimGodotObject): bool = + GC_unref(obj) + +template registerGodotClass(classNameIdent, classNameLit, isRef, baseNameLit, createFuncIdent) = proc createFuncIdent(obj: ptr GodotObject, methData: pointer): pointer {.noconv.} = let nimObj = new(classNameIdent) - setGodotObject(nimObj, obj) + nimObj.setOwn() + nimObj.setGodotObject(obj) GC_ref(nimObj) result = cast[pointer](nimObj) @@ -281,7 +294,7 @@ template registerGodotClass(classNameIdent, classNameLit, createFunc: createFuncIdent ) let destroyFuncObj = GodotInstanceDestroyFunc( - destroyFunc: nimDestroyFunc + destroyFunc: when isRef: nimDestroyRefFunc else: nimDestroyFunc ) registerClass(classNameIdent, classNameLit, false) godotScriptRegisterClass(getNativeLibHandle(), classNameLit, baseNameLit, @@ -328,7 +341,7 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, godotScriptRegisterProperty(getNativeLibHandle(), classNameLit, propNameLit, attr, setFunc, getFunc) static: - import strutils + import strutils, sets proc toGodotStyle(s: string): string {.compileTime.} = result = newStringOfCap(s.len + 10) for c in s: @@ -385,12 +398,14 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = result.add(meth.nimNode) # 4. Register Godot object - let parentName = if obj.parentName.isNil: newNilLit() + let parentName = if obj.parentName.isNil: newStrLitNode("Object") else: newStrLitNode(obj.parentName) let classNameLit = newCStringLit(obj.name) let classNameIdent = ident(obj.name) + let isRef: bool = if obj.parentName.isNil: false + else: obj.parentName in refClasses result.add(getAst( - registerGodotClass(classNameIdent, classNameLit, parentName, + registerGodotClass(classNameIdent, classNameLit, isRef, parentName, genSym(nskProc, "createFunc")))) # 5. Register fields (properties) @@ -467,6 +482,20 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = argTypes, genSym(nskProc, "methFunc"), hasReturnValue))) + if isRef: + # add ref/unref for types inherited from Reference + let noArgs = newSeq[NimNode]() + result.add(getAst( + registerGodotMethod(classNameLit, classNameIdent, ident("refcountIncremented"), + cstring"_refcount_incremented", 0, 0, + noArgs, genSym(nskProc, "refcount_incremented"), + ident("false")))) + result.add(getAst( + registerGodotMethod(classNameLit, classNameIdent, ident("refcountDecremented"), + cstring"_refcount_decremented", 0, 0, + noArgs, genSym(nskProc, "refcount_decremented"), + ident("true")))) + macro gdobj*(definition: untyped, body: untyped): typed = let typeDef = parseType(definition, callsite()) result = genType(typeDef) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index a13be85..a36ee91 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -14,7 +14,8 @@ import "../core/strings.nim", "../core/vector2.nim", "../core/rect2.nim", type NimGodotObject* = ref object of RootObj godotObject: ptr GodotObject - isRef: bool + isExternalRef: bool + isOwn: bool ConversionResult* {.pure.} = enum OK, @@ -51,7 +52,8 @@ var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo] static: import sets, strutils -var nativeClasses {.compileTime.} = initSet[string]() +var nativeClasses {.compileTime.} = newSeq[string]() +var refClasses* {.compileTime.} = newSeq[string]() var getClassMethodBind {.threadvar.}: ptr GodotMethodBind proc getClassName*(o: ptr GodotObject): string = @@ -87,7 +89,9 @@ proc deinit*(obj: NimGodotObject) = proc godotFinalizer[T: NimGodotObject](obj: T) = if obj.godotObject.isNil: return - if obj.isRef and obj.godotObject.unreference(): + if obj.isExternalRef and obj.godotObject.unreference(): + obj.deinit() + elif obj.isOwn: obj.deinit() macro baseNativeType(T: typedesc): cstring = @@ -139,9 +143,12 @@ template registerClass*(T: typedesc; godotClassName: cstring, isNative: isNativeParam, isRef: isRef ) + when isRef: + static: + refClasses.add(T.name) when isNativeParam: static: - nativeClasses.incl(T.name) + nativeClasses.add(T.name) proc newNimGodotObject[T: NimGodotObject]( godotObject: ptr GodotObject, godotClassName: cstring): T = @@ -154,7 +161,7 @@ proc newNimGodotObject[T: NimGodotObject]( result = T(objInfo.constructor()) result.godotObject = godotObject if objInfo.isRef: - result.isRef = true + result.isExternalRef = true result.godotObject.reference() proc asNimGodotObject*[T: NimGodotObject](godotObject: ptr GodotObject): T = @@ -252,6 +259,9 @@ proc setGodotObject*(nimObj: NimGodotObject, obj: ptr GodotObject) {.inline.} = assert(nimObj.godotObject.isNil) # reassignment is not allowed nimObj.godotObject = obj +proc setOwn*(nimObj: NimGodotObject) {.inline.} = + nimObj.isOwn = true + proc godotObject*(nimObj: NimGodotObject): ptr GodotObject {.inline.} = nimObj.godotObject From de89df71ade1a980741695003c8c57a808c53f18 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 00:06:45 +0700 Subject: [PATCH 007/160] Fix varargs calls --- examples/simple/src/simple.nimble | 2 +- godot.nimble | 2 +- godot/apigen/apigen.nim | 7 ++++--- godot/core/godotcore.nim | 2 +- 4 files changed, 7 insertions(+), 6 deletions(-) diff --git a/examples/simple/src/simple.nimble b/examples/simple/src/simple.nimble index 43a4780..f33fa69 100644 --- a/examples/simple/src/simple.nimble +++ b/examples/simple/src/simple.nimble @@ -4,7 +4,7 @@ description = "FPS Counter Sample" license = "MIT" bin = @["simple"] -requires "https://github.com/pragmagic/godot-nim.git >= 0.2.2 & < 0.3.0" +requires "https://github.com/pragmagic/godot-nim.git >= 0.2.3 & < 0.3.0" task make, "build": const archPostfix = when sizeof(int) == 8: "_64" else: "_32" diff --git a/godot.nimble b/godot.nimble index 712aadf..eecbb2f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.2.2" +version = "0.2.3" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/apigen/apigen.nim b/godot/apigen/apigen.nim index 8238029..85f00a1 100644 --- a/godot/apigen/apigen.nim +++ b/godot/apigen/apigen.nim @@ -416,7 +416,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], raise newException(ValueError, "Non-standard type $# for varargs params of method $# of type $#" % [arg.typ, godotMethodName, typ.godotName]) - if not isStandardType: + if not isStandardType and varargsName.isNil: if arg.typ == "string": argConversions.add(newNode(nkLetSection).addChain( newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), @@ -441,8 +441,9 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], argConversions.add(argLoop) argLoop.add(newInfix(ident("idx"), ident("<"), argLenNode) ) - argLoop.add(argAsgn) - argLoop.add(newCommand(ident("inc"), ident("idx"))) + argLoop.add(newNode(nkStmtList).addChain( + argAsgn, + newCommand(ident("inc"), ident("idx")))) let retName = if isVarargs: "callRet" else: "ptrCallRet" let theCall = newCall( diff --git a/godot/core/godotcore.nim b/godot/core/godotcore.nim index f0a0884..f0b51ff 100644 --- a/godot/core/godotcore.nim +++ b/godot/core/godotcore.nim @@ -24,7 +24,7 @@ proc ptrCall*(methodBind: ptr GodotMethodBind; importc: "godot_method_bind_ptrcall", header: "godot/gdnative.h".} proc call*(methodBind: ptr GodotMethodBind; instance: ptr GodotObject; - args: ptr array[MAX_ARG_COUNT, Variant]; argCount: cint; + args: var ptr array[MAX_ARG_COUNT, Variant]; argCount: cint; callError: var VariantCallError): Variant {. importc: "godot_method_bind_call", header: "godot/gdnative.h".} From 94f6f7c8a790911aa71d7034bd0bac37bdab2338 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 11:06:26 +0700 Subject: [PATCH 008/160] Fix checking for void and table's toGodot --- godot.nimble | 2 +- godot/nim/godotmacros.nim | 3 ++- godot/nim/godotnim.nim | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/godot.nimble b/godot.nimble index eecbb2f..371275f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.2.3" +version = "0.2.4" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 4ab140c..3e32176 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -473,7 +473,8 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = else: toGodotStyle(meth.name) let hasReturnValueBool = not (meth.returnType.isNil or meth.returnType.kind == nnkEmpty or - $meth.returnType == "void") + (meth.returnType.kind == nnkIdent and + meth.returnType.ident == !"void")) let hasReturnValue = if hasReturnValueBool: ident("true") else: ident("false") result.add(getAst( diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index a36ee91..e998ee8 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -493,7 +493,7 @@ proc godotVariantType*(T: typedesc[Table|TableRef]): VariantType {.inline.} = VariantType.Dictionary proc toGodot*[T: Table or TableRef](t: T): Variant = - let dict = initDictionary() + var dict = initDictionary() mixin toGodot for k, v in t.pairs(): dict[toGodot(k)] = toGodot(v) From 0c5e2e463c7408f2b47639528e016160020af722 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 11:36:35 +0700 Subject: [PATCH 009/160] Fix openarray toGodot --- godot/nim/godotnim.nim | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index e998ee8..12dc76b 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -456,8 +456,7 @@ proc godotVariantType*(T: typedesc[array]): VariantType = VariantType.Array proc toGodot*[T](s: openarray[T]): Variant = - var arr: Array - initArray(arr) + var arr = initArray() mixin toGodot for item in s: arr.add(toGodot(item)) From 3e2d0708e25e70e5f40a49670d0fe116b5c15893 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 12:18:00 +0700 Subject: [PATCH 010/160] Don't run finalizers during terminate --- godot/nim/godotnim.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 12dc76b..974b03f 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -563,7 +563,7 @@ proc godot_gdnative_init(options: ptr GodotNativeInitOptions) {. proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. cdecl, exportc, dynlib.} = - deallocHeap(runFinalizers = true, allowGcAfterwards = false) + deallocHeap(runFinalizers = false, allowGcAfterwards = false) proc godot_nativescript_thread_enter() {. cdecl, exportc, dynlib.} = From 4a5e0fe95f31de14d0d8447ca688d61df2ed02a5 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 12:49:09 +0700 Subject: [PATCH 011/160] Convert nil strings to empty GodotString --- godot/core/strings.nim | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/godot/core/strings.nim b/godot/core/strings.nim index 0a800ac..d8ebc30 100644 --- a/godot/core/strings.nim +++ b/godot/core/strings.nim @@ -55,8 +55,14 @@ proc `$`*(self: GodotString): string = proc toGodotString*(s: string): GodotString {.inline.} = ## Converts the Nim string into ``GodotString`` - initGodotString(result, unsafeAddr s[0], cint(s.len + 1)) + if s.isNil: + initGodotString(result) + else: + initGodotString(result, unsafeAddr s[0], cint(s.len + 1)) proc toGodotString*(s: cstring): GodotString {.inline.} = ## Converts the cstring into ``GodotString`` - initGodotString(result, s, cint(s.len + 1)) + if s.isNil: + initGodotString(result) + else: + initGodotString(result, s, cint(s.len + 1)) From 69cb8287503f4d2861e6f4ff35e0154238b4cac3 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 16:58:22 +0700 Subject: [PATCH 012/160] Fix enum toGodot --- godot/nim/godotnim.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 974b03f..d9f7f96 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -287,7 +287,7 @@ proc godotVariantType*(T: typedesc[enum]): VariantType {.inline.} = VariantType.Int proc toGodot*[T: enum](self: T): Variant {.inline.} = - variant(ord(self)) + variant(int64(ord(self))) proc fromGodot*[T: enum](self: var T, val: Variant): ConversionResult = if val.getType() == VariantType.Int: From 2fd1efcc4e5b2dd3b7eb210e306886c5feed3e35 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 27 Jul 2017 18:44:23 +0700 Subject: [PATCH 013/160] Remove dependency on headers --- examples/simple/godot_headers/godot/array.h | 122 ---- examples/simple/godot_headers/godot/basis.h | 121 ---- examples/simple/godot_headers/godot/color.h | 96 ---- .../simple/godot_headers/godot/dictionary.h | 89 --- .../simple/godot_headers/godot/gdnative.h | 302 ---------- .../simple/godot_headers/godot/node_path.h | 77 --- examples/simple/godot_headers/godot/plane.h | 93 --- .../simple/godot_headers/godot/pool_arrays.h | 316 ---------- examples/simple/godot_headers/godot/quat.h | 104 ---- examples/simple/godot_headers/godot/rect2.h | 86 --- examples/simple/godot_headers/godot/rect3.h | 108 ---- examples/simple/godot_headers/godot/rid.h | 64 --- examples/simple/godot_headers/godot/string.h | 76 --- .../simple/godot_headers/godot/transform.h | 100 ---- .../simple/godot_headers/godot/transform2d.h | 99 ---- examples/simple/godot_headers/godot/variant.h | 201 ------- examples/simple/godot_headers/godot/vector2.h | 128 ----- examples/simple/godot_headers/godot/vector3.h | 135 ----- .../simple/godot_headers/godot_nativescript.h | 228 -------- examples/simple/src/nim.cfg | 1 - examples/simple/src/simple.nimble | 4 +- godot.nimble | 2 +- godot/core/arrays.nim | 78 ++- godot/core/basis.nim | 540 ++++++++++++++---- godot/core/color.nim | 101 ++-- godot/core/dictionary.nim | 49 +- godot/core/godotbase.nim | 75 ++- godot/core/godotcore.nim | 190 +++--- godot/core/nodepath.nim | 32 +- godot/core/plane.nim | 54 +- godot/core/poolarray.nim | 270 ++++----- godot/core/quat.nim | 64 +-- godot/core/rect2.nim | 49 +- godot/core/rect3.nim | 72 +-- godot/core/rid.nim | 14 +- godot/core/strings.nim | 38 +- godot/core/transform.nim | 74 +-- godot/core/transform2d.nim | 70 +-- godot/core/variant.nim | 154 +++-- godot/core/vector2.nim | 91 ++- godot/core/vector3.nim | 325 +++++++---- godot/nim/godotnim.nim | 2 +- 42 files changed, 1280 insertions(+), 3614 deletions(-) delete mode 100644 examples/simple/godot_headers/godot/array.h delete mode 100644 examples/simple/godot_headers/godot/basis.h delete mode 100644 examples/simple/godot_headers/godot/color.h delete mode 100644 examples/simple/godot_headers/godot/dictionary.h delete mode 100644 examples/simple/godot_headers/godot/gdnative.h delete mode 100644 examples/simple/godot_headers/godot/node_path.h delete mode 100644 examples/simple/godot_headers/godot/plane.h delete mode 100644 examples/simple/godot_headers/godot/pool_arrays.h delete mode 100644 examples/simple/godot_headers/godot/quat.h delete mode 100644 examples/simple/godot_headers/godot/rect2.h delete mode 100644 examples/simple/godot_headers/godot/rect3.h delete mode 100644 examples/simple/godot_headers/godot/rid.h delete mode 100644 examples/simple/godot_headers/godot/string.h delete mode 100644 examples/simple/godot_headers/godot/transform.h delete mode 100644 examples/simple/godot_headers/godot/transform2d.h delete mode 100644 examples/simple/godot_headers/godot/variant.h delete mode 100644 examples/simple/godot_headers/godot/vector2.h delete mode 100644 examples/simple/godot_headers/godot/vector3.h delete mode 100644 examples/simple/godot_headers/godot_nativescript.h diff --git a/examples/simple/godot_headers/godot/array.h b/examples/simple/godot_headers/godot/array.h deleted file mode 100644 index cbdbfbd..0000000 --- a/examples/simple/godot_headers/godot/array.h +++ /dev/null @@ -1,122 +0,0 @@ -/*************************************************************************/ -/* array.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ - -#ifndef GODOT_ARRAY_H -#define GODOT_ARRAY_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_ARRAY_SIZE]; -} godot_array; -#endif - -#include "pool_arrays.h" -#include "variant.h" - -#include "gdnative.h" - -void GDAPI godot_array_new(godot_array *r_dest); -void GDAPI godot_array_new_copy(godot_array *r_dest, const godot_array *p_src); -void GDAPI godot_array_new_pool_color_array(godot_array *r_dest, const godot_pool_color_array *p_pca); -void GDAPI godot_array_new_pool_vector3_array(godot_array *r_dest, const godot_pool_vector3_array *p_pv3a); -void GDAPI godot_array_new_pool_vector2_array(godot_array *r_dest, const godot_pool_vector2_array *p_pv2a); -void GDAPI godot_array_new_pool_string_array(godot_array *r_dest, const godot_pool_string_array *p_psa); -void GDAPI godot_array_new_pool_real_array(godot_array *r_dest, const godot_pool_real_array *p_pra); -void GDAPI godot_array_new_pool_int_array(godot_array *r_dest, const godot_pool_int_array *p_pia); -void GDAPI godot_array_new_pool_byte_array(godot_array *r_dest, const godot_pool_byte_array *p_pba); - -void GDAPI godot_array_set(godot_array *p_self, const godot_int p_idx, const godot_variant *p_value); - -godot_variant GDAPI godot_array_get(const godot_array *p_self, const godot_int p_idx); - -godot_variant GDAPI *godot_array_operator_index(godot_array *p_self, const godot_int p_idx); - -void GDAPI godot_array_append(godot_array *p_self, const godot_variant *p_value); - -void GDAPI godot_array_clear(godot_array *p_self); - -godot_int GDAPI godot_array_count(const godot_array *p_self, const godot_variant *p_value); - -godot_bool GDAPI godot_array_empty(const godot_array *p_self); - -void GDAPI godot_array_erase(godot_array *p_self, const godot_variant *p_value); - -godot_variant GDAPI godot_array_front(const godot_array *p_self); - -godot_variant GDAPI godot_array_back(const godot_array *p_self); - -godot_int GDAPI godot_array_find(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from); - -godot_int GDAPI godot_array_find_last(const godot_array *p_self, const godot_variant *p_what); - -godot_bool GDAPI godot_array_has(const godot_array *p_self, const godot_variant *p_value); - -godot_int GDAPI godot_array_hash(const godot_array *p_self); - -void GDAPI godot_array_insert(godot_array *p_self, const godot_int p_pos, const godot_variant *p_value); - -void GDAPI godot_array_invert(godot_array *p_self); - -godot_variant GDAPI godot_array_pop_back(godot_array *p_self); - -godot_variant GDAPI godot_array_pop_front(godot_array *p_self); - -void GDAPI godot_array_push_back(godot_array *p_self, const godot_variant *p_value); - -void GDAPI godot_array_push_front(godot_array *p_self, const godot_variant *p_value); - -void GDAPI godot_array_remove(godot_array *p_self, const godot_int p_idx); - -void GDAPI godot_array_resize(godot_array *p_self, const godot_int p_size); - -godot_int GDAPI godot_array_rfind(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from); - -godot_int GDAPI godot_array_size(const godot_array *p_self); - -void GDAPI godot_array_sort(godot_array *p_self); - -void GDAPI godot_array_sort_custom(godot_array *p_self, godot_object *p_obj, const godot_string *p_func); - -void GDAPI godot_array_destroy(godot_array *p_self); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_ARRAY_H diff --git a/examples/simple/godot_headers/godot/basis.h b/examples/simple/godot_headers/godot/basis.h deleted file mode 100644 index 79b2b45..0000000 --- a/examples/simple/godot_headers/godot/basis.h +++ /dev/null @@ -1,121 +0,0 @@ -/*************************************************************************/ -/* basis.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_BASIS_H -#define GODOT_BASIS_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_BASIS_SIZE 36 - -#ifndef GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_BASIS_SIZE]; -} godot_basis; -#endif - -#include "gdnative.h" -#include "quat.h" -#include "vector3.h" - -void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis); -void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi); -void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler); - -godot_string GDAPI godot_basis_as_string(const godot_basis *p_self); - -godot_basis GDAPI godot_basis_inverse(const godot_basis *p_self); - -godot_basis GDAPI godot_basis_transposed(const godot_basis *p_self); - -godot_basis GDAPI godot_basis_orthonormalized(const godot_basis *p_self); - -godot_real GDAPI godot_basis_determinant(const godot_basis *p_self); - -godot_basis GDAPI godot_basis_rotated(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi); - -godot_basis GDAPI godot_basis_scaled(const godot_basis *p_self, const godot_vector3 *p_scale); - -void GDAPI godot_basis_set_scale(godot_basis *p_self, const godot_vector3 *p_scale); - -void GDAPI godot_basis_set_rotation_euler(godot_basis *p_self, const godot_vector3 *p_euler); - -void GDAPI godot_basis_set_rotation_axis_angle(godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_angle); - -godot_vector3 GDAPI godot_basis_get_scale(const godot_basis *p_self); - -godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_self); - -godot_real GDAPI godot_basis_tdotx(const godot_basis *p_self, const godot_vector3 *p_with); - -godot_real GDAPI godot_basis_tdoty(const godot_basis *p_self, const godot_vector3 *p_with); - -godot_real GDAPI godot_basis_tdotz(const godot_basis *p_self, const godot_vector3 *p_with); - -godot_vector3 GDAPI godot_basis_xform(const godot_basis *p_self, const godot_vector3 *p_v); - -godot_vector3 GDAPI godot_basis_xform_inv(const godot_basis *p_self, const godot_vector3 *p_v); - -godot_int GDAPI godot_basis_get_orthogonal_index(const godot_basis *p_self); - -void GDAPI godot_basis_new(godot_basis *r_dest); - -void GDAPI godot_basis_new_with_euler_quat(godot_basis *r_dest, const godot_quat *p_euler); - -// p_elements is a pointer to an array of 3 (!!) vector3 -void GDAPI godot_basis_get_elements(godot_basis *p_self, godot_vector3 *p_elements); - -godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_self, const godot_int p_axis); - -void GDAPI godot_basis_set_axis(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value); - -godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_self, const godot_int p_row); - -void GDAPI godot_basis_set_row(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value); - -godot_bool GDAPI godot_basis_operator_equal(const godot_basis *p_self, const godot_basis *p_b); - -godot_basis GDAPI godot_basis_operator_add(const godot_basis *p_self, const godot_basis *p_b); - -godot_basis GDAPI godot_basis_operator_substract(const godot_basis *p_self, const godot_basis *p_b); - -godot_basis GDAPI godot_basis_operator_multiply_vector(const godot_basis *p_self, const godot_basis *p_b); - -godot_basis GDAPI godot_basis_operator_multiply_scalar(const godot_basis *p_self, const godot_real p_b); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_BASIS_H diff --git a/examples/simple/godot_headers/godot/color.h b/examples/simple/godot_headers/godot/color.h deleted file mode 100644 index 77e709f..0000000 --- a/examples/simple/godot_headers/godot/color.h +++ /dev/null @@ -1,96 +0,0 @@ -/*************************************************************************/ -/* color.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_COLOR_H -#define GODOT_COLOR_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_COLOR_SIZE 16 - -#ifndef GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_COLOR_SIZE]; -} godot_color; -#endif - -#include "gdnative.h" -#include "string.h" - -void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a); -void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b); - -godot_real godot_color_get_r(const godot_color *p_self); -void godot_color_set_r(godot_color *p_self, const godot_real r); - -godot_real godot_color_get_g(const godot_color *p_self); -void godot_color_set_g(godot_color *p_self, const godot_real g); - -godot_real godot_color_get_b(const godot_color *p_self); -void godot_color_set_b(godot_color *p_self, const godot_real b); - -godot_real godot_color_get_a(const godot_color *p_self); -void godot_color_set_a(godot_color *p_self, const godot_real a); - -godot_real godot_color_get_h(const godot_color *p_self); -godot_real godot_color_get_s(const godot_color *p_self); -godot_real godot_color_get_v(const godot_color *p_self); - -godot_string GDAPI godot_color_as_string(const godot_color *p_self); - -godot_int GDAPI godot_color_to_32(const godot_color *p_self); - -godot_int GDAPI godot_color_to_ARGB32(const godot_color *p_self); - -godot_real GDAPI godot_color_gray(const godot_color *p_self); - -godot_color GDAPI godot_color_inverted(const godot_color *p_self); - -godot_color GDAPI godot_color_contrasted(const godot_color *p_self); - -godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t); - -godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over); - -godot_string GDAPI godot_color_to_html(const godot_color *p_self, const godot_bool p_with_alpha); - -godot_bool GDAPI godot_color_operator_equal(const godot_color *p_self, const godot_color *p_b); - -godot_bool GDAPI godot_color_operator_less(const godot_color *p_self, const godot_color *p_b); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_COLOR_H diff --git a/examples/simple/godot_headers/godot/dictionary.h b/examples/simple/godot_headers/godot/dictionary.h deleted file mode 100644 index a08deb2..0000000 --- a/examples/simple/godot_headers/godot/dictionary.h +++ /dev/null @@ -1,89 +0,0 @@ -/*************************************************************************/ -/* dictionary.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_DICTIONARY_H -#define GODOT_DICTIONARY_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_DICTIONARY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_DICTIONARY_SIZE]; -} godot_dictionary; -#endif - -#include "array.h" -#include "gdnative.h" -#include "variant.h" - -void GDAPI godot_dictionary_new(godot_dictionary *r_dest); -void GDAPI godot_dictionary_new_copy(godot_dictionary *r_dest, const godot_dictionary *p_src); -void GDAPI godot_dictionary_destroy(godot_dictionary *p_self); - -godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_self); - -godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_self); - -void GDAPI godot_dictionary_clear(godot_dictionary *p_self); - -godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_self, const godot_variant *p_key); - -godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_self, const godot_array *p_keys); - -void GDAPI godot_dictionary_erase(godot_dictionary *p_self, const godot_variant *p_key); - -godot_int GDAPI godot_dictionary_hash(const godot_dictionary *p_self); - -godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_self); - -godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_self); - -godot_variant GDAPI godot_dictionary_get(const godot_dictionary *p_self, const godot_variant *p_key); -void GDAPI godot_dictionary_set(godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value); - -godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_self, const godot_variant *p_key); - -godot_variant GDAPI *godot_dictionary_next(const godot_dictionary *p_self, const godot_variant *p_key); - -godot_bool GDAPI godot_dictionary_operator_equal(const godot_dictionary *p_self, const godot_dictionary *p_b); - -godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_self); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_DICTIONARY_H diff --git a/examples/simple/godot_headers/godot/gdnative.h b/examples/simple/godot_headers/godot/gdnative.h deleted file mode 100644 index 510bf36..0000000 --- a/examples/simple/godot_headers/godot/gdnative.h +++ /dev/null @@ -1,302 +0,0 @@ -/*************************************************************************/ -/* gdnative.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_GDNATIVE_H -#define GODOT_GDNATIVE_H - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef GDAPI_BUILT_IN -#define GDAPI_EXPORT -#endif - -#ifdef _WIN32 -#if defined(GDAPI_EXPORT) -#define GDCALLINGCONV -#define GDAPI __declspec(dllexport) GDCALLINGCONV -#else -#define GDCALLINGCONV -#define GDAPI __declspec(dllimport) GDCALLINGCONV -#endif -#elif defined(__APPLE__) -#include "TargetConditionals.h" -#if TARGET_OS_IPHONE -#define GDCALLINGCONV -#define GDAPI -#elif TARGET_OS_MAC -#define GDCALLINGCONV __attribute__((sysv_abi)) -#define GDAPI GDCALLINGCONV -#endif -#else -#define GDCALLINGCONV __attribute__((sysv_abi)) -#define GDAPI GDCALLINGCONV -#endif - -// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!! -#ifdef _WIN32 -#define GDN_EXPORT __declspec(dllexport) -#else -#define GDN_EXPORT -#endif - -#include -#include - -#define GODOT_API_VERSION 1 - -////// Error - -typedef enum { - GODOT_OK, - GODOT_FAILED, ///< Generic fail error - GODOT_ERR_UNAVAILABLE, ///< What is requested is unsupported/unavailable - GODOT_ERR_UNCONFIGURED, ///< The object being used hasnt been properly set up yet - GODOT_ERR_UNAUTHORIZED, ///< Missing credentials for requested resource - GODOT_ERR_PARAMETER_RANGE_ERROR, ///< Parameter given out of range (5) - GODOT_ERR_OUT_OF_MEMORY, ///< Out of memory - GODOT_ERR_FILE_NOT_FOUND, - GODOT_ERR_FILE_BAD_DRIVE, - GODOT_ERR_FILE_BAD_PATH, - GODOT_ERR_FILE_NO_PERMISSION, // (10) - GODOT_ERR_FILE_ALREADY_IN_USE, - GODOT_ERR_FILE_CANT_OPEN, - GODOT_ERR_FILE_CANT_WRITE, - GODOT_ERR_FILE_CANT_READ, - GODOT_ERR_FILE_UNRECOGNIZED, // (15) - GODOT_ERR_FILE_CORRUPT, - GODOT_ERR_FILE_MISSING_DEPENDENCIES, - GODOT_ERR_FILE_EOF, - GODOT_ERR_CANT_OPEN, ///< Can't open a resource/socket/file - GODOT_ERR_CANT_CREATE, // (20) - GODOT_ERR_QUERY_FAILED, - GODOT_ERR_ALREADY_IN_USE, - GODOT_ERR_LOCKED, ///< resource is locked - GODOT_ERR_TIMEOUT, - GODOT_ERR_CANT_CONNECT, // (25) - GODOT_ERR_CANT_RESOLVE, - GODOT_ERR_CONNECTION_ERROR, - GODOT_ERR_CANT_AQUIRE_RESOURCE, - GODOT_ERR_CANT_FORK, - GODOT_ERR_INVALID_DATA, ///< Data passed is invalid (30) - GODOT_ERR_INVALID_PARAMETER, ///< Parameter passed is invalid - GODOT_ERR_ALREADY_EXISTS, ///< When adding, item already exists - GODOT_ERR_DOES_NOT_EXIST, ///< When retrieving/erasing, it item does not exist - GODOT_ERR_DATABASE_CANT_READ, ///< database is full - GODOT_ERR_DATABASE_CANT_WRITE, ///< database is full (35) - GODOT_ERR_COMPILATION_FAILED, - GODOT_ERR_METHOD_NOT_FOUND, - GODOT_ERR_LINK_FAILED, - GODOT_ERR_SCRIPT_FAILED, - GODOT_ERR_CYCLIC_LINK, // (40) - GODOT_ERR_INVALID_DECLARATION, - GODOT_ERR_DUPLICATE_SYMBOL, - GODOT_ERR_PARSE_ERROR, - GODOT_ERR_BUSY, - GODOT_ERR_SKIP, // (45) - GODOT_ERR_HELP, ///< user requested help!! - GODOT_ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior. - GODOT_ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames - GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD, ///< shit happens, has never been used, though - GODOT_ERR_WTF = GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD ///< short version of the above -} godot_error; - -////// bool - -typedef bool godot_bool; - -#define GODOT_TRUE 1 -#define GODOT_FALSE 0 - -/////// int - -typedef int godot_int; - -/////// real - -typedef float godot_real; - -/////// Object (forward declared) -typedef void godot_object; - -/////// Brute force forward declarations for the rest -/* -typedef struct godot_variant godot_variant; -typedef struct godot_string godot_string; -typedef struct godot_vector2 godot_vector2; -typedef struct godot_rect2 godot_rect2; -typedef struct godot_vector3 godot_vector3; -typedef struct godot_transform2d godot_transform2d; -typedef struct godot_plane godot_plane; -typedef struct godot_quat godot_quat; -typedef struct godot_rect3 godot_rect3; -typedef struct godot_basis godot_basis; -typedef struct godot_transform godot_transform; -typedef struct godot_color godot_color; -typedef struct godot_node_path godot_node_path; -typedef struct godot_rid godot_rid; -typedef struct godot_dictionary godot_dictionary; -typedef struct godot_array godot_array; -typedef struct godot_pool_byte_array godot_pool_byte_array; -typedef struct godot_pool_int_array godot_pool_int_array; -typedef struct godot_pool_real_array godot_pool_real_array; -typedef struct godot_pool_string_array godot_pool_string_array; -typedef struct godot_pool_vector2_array godot_pool_vector2_array; -typedef struct godot_pool_vector3_array godot_pool_vector3_array; -typedef struct godot_pool_color_array godot_pool_color_array; -*/ -/////// String - -#include "string.h" - -////// Vector2 - -#include "vector2.h" - -////// Rect2 - -#include "rect2.h" - -////// Vector3 - -#include "vector3.h" - -////// Transform2D - -#include "transform2d.h" - -/////// Plane - -#include "plane.h" - -/////// Quat - -#include "quat.h" - -/////// Rect3 - -#include "rect3.h" - -/////// Basis - -#include "basis.h" - -/////// Transform - -#include "transform.h" - -/////// Color - -#include "color.h" - -/////// NodePath - -#include "node_path.h" - -/////// RID - -#include "rid.h" - -/////// Dictionary - -#include "dictionary.h" - -/////// Array - -#include "array.h" - -// single API file for Pool*Array -#include "pool_arrays.h" - -void GDAPI godot_object_destroy(godot_object *p_o); - -////// Variant - -#include "variant.h" - -////// Singleton API - -godot_object GDAPI *godot_global_get_singleton(char *p_name); // result shouldn't be freed - -////// OS API - -void GDAPI *godot_get_stack_bottom(); // returns stack bottom of the main thread - -////// MethodBind API - -typedef struct { - uint8_t _dont_touch_that[1]; // TODO -} godot_method_bind; - -godot_method_bind GDAPI *godot_method_bind_get_method(const char *p_classname, const char *p_methodname); -void GDAPI godot_method_bind_ptrcall(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret); -godot_variant GDAPI godot_method_bind_call(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error); -////// Script API - -typedef struct { - godot_bool in_editor; - uint64_t core_api_hash; - uint64_t editor_api_hash; - uint64_t no_api_hash; -} godot_gdnative_init_options; - -typedef struct { - godot_bool in_editor; -} godot_gdnative_terminate_options; - -// Calling convention? -typedef godot_object *(*godot_class_constructor)(); - -godot_class_constructor GDAPI godot_get_class_constructor(const char *p_classname); - -godot_dictionary GDAPI godot_get_global_constants(); - -////// GDNative procedure types -typedef void (*godot_gdnative_init_fn)(godot_gdnative_init_options *); -typedef void (*godot_gdnative_terminate_fn)(godot_gdnative_terminate_options *); -typedef godot_variant (*godot_gdnative_procedure_fn)(void *, godot_array *); - -////// System Functions - -//using these will help Godot track how much memory is in use in debug mode -void GDAPI *godot_alloc(int p_bytes); -void GDAPI *godot_realloc(void *p_ptr, int p_bytes); -void GDAPI godot_free(void *p_ptr); - -//print using Godot's error handler list -void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line); -void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line); -void GDAPI godot_print(const godot_string *p_message); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_C_H diff --git a/examples/simple/godot_headers/godot/node_path.h b/examples/simple/godot_headers/godot/node_path.h deleted file mode 100644 index 06955a0..0000000 --- a/examples/simple/godot_headers/godot/node_path.h +++ /dev/null @@ -1,77 +0,0 @@ -/*************************************************************************/ -/* node_path.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_NODE_PATH_H -#define GODOT_NODE_PATH_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_NODE_PATH_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_NODE_PATH_SIZE]; -} godot_node_path; -#endif - -#include "gdnative.h" -#include "string.h" - -void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from); -void GDAPI godot_node_path_new_copy(godot_node_path *r_dest, const godot_node_path *p_src); -void GDAPI godot_node_path_destroy(godot_node_path *p_self); - -godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_self); - -godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_self); - -godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_self); - -godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_self, const godot_int p_idx); - -godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_self); - -godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_self, const godot_int p_idx); - -godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_self); - -godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_self); - -godot_bool GDAPI godot_node_path_operator_equal(const godot_node_path *p_self, const godot_node_path *p_b); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_NODE_PATH_H diff --git a/examples/simple/godot_headers/godot/plane.h b/examples/simple/godot_headers/godot/plane.h deleted file mode 100644 index e9e3b71..0000000 --- a/examples/simple/godot_headers/godot/plane.h +++ /dev/null @@ -1,93 +0,0 @@ -/*************************************************************************/ -/* plane.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_PLANE_H -#define GODOT_PLANE_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_PLANE_SIZE 16 - -#ifndef GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_PLANE_SIZE]; -} godot_plane; -#endif - -#include "gdnative.h" -#include "vector3.h" - -void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d); -void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3); -void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d); - -godot_string GDAPI godot_plane_as_string(const godot_plane *p_self); - -godot_plane GDAPI godot_plane_normalized(const godot_plane *p_self); - -godot_vector3 GDAPI godot_plane_center(const godot_plane *p_self); - -godot_vector3 GDAPI godot_plane_get_any_point(const godot_plane *p_self); - -godot_bool GDAPI godot_plane_is_point_over(const godot_plane *p_self, const godot_vector3 *p_point); - -godot_real GDAPI godot_plane_distance_to(const godot_plane *p_self, const godot_vector3 *p_point); - -godot_bool GDAPI godot_plane_has_point(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon); - -godot_vector3 GDAPI godot_plane_project(const godot_plane *p_self, const godot_vector3 *p_point); - -godot_bool GDAPI godot_plane_intersect_3(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c); - -godot_bool GDAPI godot_plane_intersects_ray(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir); - -godot_bool GDAPI godot_plane_intersects_segment(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end); - -godot_plane GDAPI godot_plane_operator_neg(const godot_plane *p_self); - -godot_bool GDAPI godot_plane_operator_equal(const godot_plane *p_self, const godot_plane *p_b); - -void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_normal); - -godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self); - -godot_real GDAPI godot_plane_get_d(const godot_plane *p_self); - -void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_PLANE_H diff --git a/examples/simple/godot_headers/godot/pool_arrays.h b/examples/simple/godot_headers/godot/pool_arrays.h deleted file mode 100644 index 1e2916c..0000000 --- a/examples/simple/godot_headers/godot/pool_arrays.h +++ /dev/null @@ -1,316 +0,0 @@ -/*************************************************************************/ -/* pool_arrays.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_POOL_ARRAYS_H -#define GODOT_POOL_ARRAYS_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -/////// PoolByteArray - -#define GODOT_POOL_BYTE_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_BYTE_ARRAY_SIZE]; -} godot_pool_byte_array; -#endif - -/////// PoolIntArray - -#define GODOT_POOL_INT_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_INT_ARRAY_SIZE]; -} godot_pool_int_array; -#endif - -/////// PoolRealArray - -#define GODOT_POOL_REAL_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_REAL_ARRAY_SIZE]; -} godot_pool_real_array; -#endif - -/////// PoolStringArray - -#define GODOT_POOL_STRING_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_STRING_ARRAY_SIZE]; -} godot_pool_string_array; -#endif - -/////// PoolVector2Array - -#define GODOT_POOL_VECTOR2_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_VECTOR2_ARRAY_SIZE]; -} godot_pool_vector2_array; -#endif - -/////// PoolVector3Array - -#define GODOT_POOL_VECTOR3_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_VECTOR3_ARRAY_SIZE]; -} godot_pool_vector3_array; -#endif - -/////// PoolColorArray - -#define GODOT_POOL_COLOR_ARRAY_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_POOL_COLOR_ARRAY_SIZE]; -} godot_pool_color_array; -#endif - -#include "array.h" -#include "color.h" -#include "vector2.h" -#include "vector3.h" - -#include "gdnative.h" - -// byte - -void GDAPI godot_pool_byte_array_new(godot_pool_byte_array *r_dest); -void GDAPI godot_pool_byte_array_new_copy(godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src); -void GDAPI godot_pool_byte_array_new_with_array(godot_pool_byte_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_byte_array_append(godot_pool_byte_array *p_self, const uint8_t p_data); - -void GDAPI godot_pool_byte_array_append_array(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array); - -godot_error GDAPI godot_pool_byte_array_insert(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data); - -void GDAPI godot_pool_byte_array_invert(godot_pool_byte_array *p_self); - -void GDAPI godot_pool_byte_array_push_back(godot_pool_byte_array *p_self, const uint8_t p_data); - -void GDAPI godot_pool_byte_array_remove(godot_pool_byte_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_byte_array_resize(godot_pool_byte_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_byte_array_set(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data); -uint8_t GDAPI godot_pool_byte_array_get(const godot_pool_byte_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_byte_array_size(const godot_pool_byte_array *p_self); - -void GDAPI godot_pool_byte_array_destroy(godot_pool_byte_array *p_self); - -// int - -void GDAPI godot_pool_int_array_new(godot_pool_int_array *r_dest); -void GDAPI godot_pool_int_array_new_copy(godot_pool_int_array *r_dest, const godot_pool_int_array *p_src); -void GDAPI godot_pool_int_array_new_with_array(godot_pool_int_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_int_array_append(godot_pool_int_array *p_self, const godot_int p_data); - -void GDAPI godot_pool_int_array_append_array(godot_pool_int_array *p_self, const godot_pool_int_array *p_array); - -godot_error GDAPI godot_pool_int_array_insert(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data); - -void GDAPI godot_pool_int_array_invert(godot_pool_int_array *p_self); - -void GDAPI godot_pool_int_array_push_back(godot_pool_int_array *p_self, const godot_int p_data); - -void GDAPI godot_pool_int_array_remove(godot_pool_int_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_int_array_resize(godot_pool_int_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_int_array_set(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data); -godot_int GDAPI godot_pool_int_array_get(const godot_pool_int_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_int_array_size(const godot_pool_int_array *p_self); - -void GDAPI godot_pool_int_array_destroy(godot_pool_int_array *p_self); - -// real - -void GDAPI godot_pool_real_array_new(godot_pool_real_array *r_dest); -void GDAPI godot_pool_real_array_new_copy(godot_pool_real_array *r_dest, const godot_pool_real_array *p_src); -void GDAPI godot_pool_real_array_new_with_array(godot_pool_real_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_real_array_append(godot_pool_real_array *p_self, const godot_real p_data); - -void GDAPI godot_pool_real_array_append_array(godot_pool_real_array *p_self, const godot_pool_real_array *p_array); - -godot_error GDAPI godot_pool_real_array_insert(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data); - -void GDAPI godot_pool_real_array_invert(godot_pool_real_array *p_self); - -void GDAPI godot_pool_real_array_push_back(godot_pool_real_array *p_self, const godot_real p_data); - -void GDAPI godot_pool_real_array_remove(godot_pool_real_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_real_array_resize(godot_pool_real_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_real_array_set(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data); -godot_real GDAPI godot_pool_real_array_get(const godot_pool_real_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_real_array_size(const godot_pool_real_array *p_self); - -void GDAPI godot_pool_real_array_destroy(godot_pool_real_array *p_self); - -// string - -void GDAPI godot_pool_string_array_new(godot_pool_string_array *r_dest); -void GDAPI godot_pool_string_array_new_copy(godot_pool_string_array *r_dest, const godot_pool_string_array *p_src); -void GDAPI godot_pool_string_array_new_with_array(godot_pool_string_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_string_array_append(godot_pool_string_array *p_self, const godot_string *p_data); - -void GDAPI godot_pool_string_array_append_array(godot_pool_string_array *p_self, const godot_pool_string_array *p_array); - -godot_error GDAPI godot_pool_string_array_insert(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data); - -void GDAPI godot_pool_string_array_invert(godot_pool_string_array *p_self); - -void GDAPI godot_pool_string_array_push_back(godot_pool_string_array *p_self, const godot_string *p_data); - -void GDAPI godot_pool_string_array_remove(godot_pool_string_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_string_array_resize(godot_pool_string_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_string_array_set(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data); -godot_string GDAPI godot_pool_string_array_get(const godot_pool_string_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_string_array_size(const godot_pool_string_array *p_self); - -void GDAPI godot_pool_string_array_destroy(godot_pool_string_array *p_self); - -// vector2 - -void GDAPI godot_pool_vector2_array_new(godot_pool_vector2_array *r_dest); -void GDAPI godot_pool_vector2_array_new_copy(godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src); -void GDAPI godot_pool_vector2_array_new_with_array(godot_pool_vector2_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_vector2_array_append(godot_pool_vector2_array *p_self, const godot_vector2 *p_data); - -void GDAPI godot_pool_vector2_array_append_array(godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array); - -godot_error GDAPI godot_pool_vector2_array_insert(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data); - -void GDAPI godot_pool_vector2_array_invert(godot_pool_vector2_array *p_self); - -void GDAPI godot_pool_vector2_array_push_back(godot_pool_vector2_array *p_self, const godot_vector2 *p_data); - -void GDAPI godot_pool_vector2_array_remove(godot_pool_vector2_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_vector2_array_resize(godot_pool_vector2_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_vector2_array_set(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data); -godot_vector2 GDAPI godot_pool_vector2_array_get(const godot_pool_vector2_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_vector2_array_size(const godot_pool_vector2_array *p_self); - -void GDAPI godot_pool_vector2_array_destroy(godot_pool_vector2_array *p_self); - -// vector3 - -void GDAPI godot_pool_vector3_array_new(godot_pool_vector3_array *r_dest); -void GDAPI godot_pool_vector3_array_new_copy(godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src); -void GDAPI godot_pool_vector3_array_new_with_array(godot_pool_vector3_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_vector3_array_append(godot_pool_vector3_array *p_self, const godot_vector3 *p_data); - -void GDAPI godot_pool_vector3_array_append_array(godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array); - -godot_error GDAPI godot_pool_vector3_array_insert(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data); - -void GDAPI godot_pool_vector3_array_invert(godot_pool_vector3_array *p_self); - -void GDAPI godot_pool_vector3_array_push_back(godot_pool_vector3_array *p_self, const godot_vector3 *p_data); - -void GDAPI godot_pool_vector3_array_remove(godot_pool_vector3_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_vector3_array_resize(godot_pool_vector3_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_vector3_array_set(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data); -godot_vector3 GDAPI godot_pool_vector3_array_get(const godot_pool_vector3_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_vector3_array_size(const godot_pool_vector3_array *p_self); - -void GDAPI godot_pool_vector3_array_destroy(godot_pool_vector3_array *p_self); - -// color - -void GDAPI godot_pool_color_array_new(godot_pool_color_array *r_dest); -void GDAPI godot_pool_color_array_new_copy(godot_pool_color_array *r_dest, const godot_pool_color_array *p_src); -void GDAPI godot_pool_color_array_new_with_array(godot_pool_color_array *r_dest, const godot_array *p_a); - -void GDAPI godot_pool_color_array_append(godot_pool_color_array *p_self, const godot_color *p_data); - -void GDAPI godot_pool_color_array_append_array(godot_pool_color_array *p_self, const godot_pool_color_array *p_array); - -godot_error GDAPI godot_pool_color_array_insert(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data); - -void GDAPI godot_pool_color_array_invert(godot_pool_color_array *p_self); - -void GDAPI godot_pool_color_array_push_back(godot_pool_color_array *p_self, const godot_color *p_data); - -void GDAPI godot_pool_color_array_remove(godot_pool_color_array *p_self, const godot_int p_idx); - -void GDAPI godot_pool_color_array_resize(godot_pool_color_array *p_self, const godot_int p_size); - -void GDAPI godot_pool_color_array_set(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data); -godot_color GDAPI godot_pool_color_array_get(const godot_pool_color_array *p_self, const godot_int p_idx); - -godot_int GDAPI godot_pool_color_array_size(const godot_pool_color_array *p_self); - -void GDAPI godot_pool_color_array_destroy(godot_pool_color_array *p_self); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_POOL_ARRAYS_H diff --git a/examples/simple/godot_headers/godot/quat.h b/examples/simple/godot_headers/godot/quat.h deleted file mode 100644 index b86cbac..0000000 --- a/examples/simple/godot_headers/godot/quat.h +++ /dev/null @@ -1,104 +0,0 @@ -/*************************************************************************/ -/* quat.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_QUAT_H -#define GODOT_QUAT_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_QUAT_SIZE 16 - -#ifndef GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_QUAT_SIZE]; -} godot_quat; -#endif - -#include "gdnative.h" -#include "vector3.h" - -void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w); -void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle); - -godot_real GDAPI godot_quat_get_x(const godot_quat *p_self); -void GDAPI godot_quat_set_x(godot_quat *p_self, const godot_real val); - -godot_real GDAPI godot_quat_get_y(const godot_quat *p_self); -void GDAPI godot_quat_set_y(godot_quat *p_self, const godot_real val); - -godot_real GDAPI godot_quat_get_z(const godot_quat *p_self); -void GDAPI godot_quat_set_z(godot_quat *p_self, const godot_real val); - -godot_real GDAPI godot_quat_get_w(const godot_quat *p_self); -void GDAPI godot_quat_set_w(godot_quat *p_self, const godot_real val); - -godot_string GDAPI godot_quat_as_string(const godot_quat *p_self); - -godot_real GDAPI godot_quat_length(const godot_quat *p_self); - -godot_real GDAPI godot_quat_length_squared(const godot_quat *p_self); - -godot_quat GDAPI godot_quat_normalized(const godot_quat *p_self); - -godot_bool GDAPI godot_quat_is_normalized(const godot_quat *p_self); - -godot_quat GDAPI godot_quat_inverse(const godot_quat *p_self); - -godot_real GDAPI godot_quat_dot(const godot_quat *p_self, const godot_quat *p_b); - -godot_vector3 GDAPI godot_quat_xform(const godot_quat *p_self, const godot_vector3 *p_v); - -godot_quat GDAPI godot_quat_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t); - -godot_quat GDAPI godot_quat_slerpni(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t); - -godot_quat GDAPI godot_quat_cubic_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t); - -godot_quat GDAPI godot_quat_operator_multiply(const godot_quat *p_self, const godot_real p_b); - -godot_quat GDAPI godot_quat_operator_add(const godot_quat *p_self, const godot_quat *p_b); - -godot_quat GDAPI godot_quat_operator_substract(const godot_quat *p_self, const godot_quat *p_b); - -godot_quat GDAPI godot_quat_operator_divide(const godot_quat *p_self, const godot_real p_b); - -godot_bool GDAPI godot_quat_operator_equal(const godot_quat *p_self, const godot_quat *p_b); - -godot_quat GDAPI godot_quat_operator_neg(const godot_quat *p_self); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_QUAT_H diff --git a/examples/simple/godot_headers/godot/rect2.h b/examples/simple/godot_headers/godot/rect2.h deleted file mode 100644 index 7b6613d..0000000 --- a/examples/simple/godot_headers/godot/rect2.h +++ /dev/null @@ -1,86 +0,0 @@ -/*************************************************************************/ -/* rect2.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_RECT2_H -#define GODOT_RECT2_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#ifndef GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED -typedef struct godot_rect2 { - uint8_t _dont_touch_that[16]; -} godot_rect2; -#endif - -#include "gdnative.h" -#include "vector2.h" - -void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size); -void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height); - -godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self); - -godot_real GDAPI godot_rect2_get_area(const godot_rect2 *p_self); - -godot_bool GDAPI godot_rect2_intersects(const godot_rect2 *p_self, const godot_rect2 *p_b); - -godot_bool GDAPI godot_rect2_encloses(const godot_rect2 *p_self, const godot_rect2 *p_b); - -godot_bool GDAPI godot_rect2_has_no_area(const godot_rect2 *p_self); - -godot_rect2 GDAPI godot_rect2_clip(const godot_rect2 *p_self, const godot_rect2 *p_b); - -godot_rect2 GDAPI godot_rect2_merge(const godot_rect2 *p_self, const godot_rect2 *p_b); - -godot_bool GDAPI godot_rect2_has_point(const godot_rect2 *p_self, const godot_vector2 *p_point); - -godot_rect2 GDAPI godot_rect2_grow(const godot_rect2 *p_self, const godot_real p_by); - -godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vector2 *p_to); - -godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b); - -godot_vector2 GDAPI godot_rect2_get_position(const godot_rect2 *p_self); - -godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self); - -void GDAPI godot_rect2_set_position(godot_rect2 *p_self, const godot_vector2 *p_pos); - -void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_RECT2_H diff --git a/examples/simple/godot_headers/godot/rect3.h b/examples/simple/godot_headers/godot/rect3.h deleted file mode 100644 index 638d89f..0000000 --- a/examples/simple/godot_headers/godot/rect3.h +++ /dev/null @@ -1,108 +0,0 @@ -/*************************************************************************/ -/* rect3.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_RECT3_H -#define GODOT_RECT3_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_RECT3_SIZE 24 - -#ifndef GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_RECT3_SIZE]; -} godot_rect3; -#endif - -#include "gdnative.h" -#include "plane.h" -#include "vector3.h" - -void GDAPI godot_rect3_new(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size); - -godot_vector3 GDAPI godot_rect3_get_position(const godot_rect3 *p_self); -void GDAPI godot_rect3_set_position(const godot_rect3 *p_self, const godot_vector3 *p_v); - -godot_vector3 GDAPI godot_rect3_get_size(const godot_rect3 *p_self); -void GDAPI godot_rect3_set_size(const godot_rect3 *p_self, const godot_vector3 *p_v); - -godot_string GDAPI godot_rect3_as_string(const godot_rect3 *p_self); - -godot_real GDAPI godot_rect3_get_area(const godot_rect3 *p_self); - -godot_bool GDAPI godot_rect3_has_no_area(const godot_rect3 *p_self); - -godot_bool GDAPI godot_rect3_has_no_surface(const godot_rect3 *p_self); - -godot_bool GDAPI godot_rect3_intersects(const godot_rect3 *p_self, const godot_rect3 *p_with); - -godot_bool GDAPI godot_rect3_encloses(const godot_rect3 *p_self, const godot_rect3 *p_with); - -godot_rect3 GDAPI godot_rect3_merge(const godot_rect3 *p_self, const godot_rect3 *p_with); - -godot_rect3 GDAPI godot_rect3_intersection(const godot_rect3 *p_self, const godot_rect3 *p_with); - -godot_bool GDAPI godot_rect3_intersects_plane(const godot_rect3 *p_self, const godot_plane *p_plane); - -godot_bool GDAPI godot_rect3_intersects_segment(const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to); - -godot_bool GDAPI godot_rect3_has_point(const godot_rect3 *p_self, const godot_vector3 *p_point); - -godot_vector3 GDAPI godot_rect3_get_support(const godot_rect3 *p_self, const godot_vector3 *p_dir); - -godot_vector3 GDAPI godot_rect3_get_longest_axis(const godot_rect3 *p_self); - -godot_int GDAPI godot_rect3_get_longest_axis_index(const godot_rect3 *p_self); - -godot_real GDAPI godot_rect3_get_longest_axis_size(const godot_rect3 *p_self); - -godot_vector3 GDAPI godot_rect3_get_shortest_axis(const godot_rect3 *p_self); - -godot_int GDAPI godot_rect3_get_shortest_axis_index(const godot_rect3 *p_self); - -godot_real GDAPI godot_rect3_get_shortest_axis_size(const godot_rect3 *p_self); - -godot_rect3 GDAPI godot_rect3_expand(const godot_rect3 *p_self, const godot_vector3 *p_to_point); - -godot_rect3 GDAPI godot_rect3_grow(const godot_rect3 *p_self, const godot_real p_by); - -godot_vector3 GDAPI godot_rect3_get_endpoint(const godot_rect3 *p_self, const godot_int p_idx); - -godot_bool GDAPI godot_rect3_operator_equal(const godot_rect3 *p_self, const godot_rect3 *p_b); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_RECT3_H diff --git a/examples/simple/godot_headers/godot/rid.h b/examples/simple/godot_headers/godot/rid.h deleted file mode 100644 index 92e101f..0000000 --- a/examples/simple/godot_headers/godot/rid.h +++ /dev/null @@ -1,64 +0,0 @@ -/*************************************************************************/ -/* rid.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_RID_H -#define GODOT_RID_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_RID_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_RID_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_RID_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_RID_SIZE]; -} godot_rid; -#endif - -#include "gdnative.h" - -void GDAPI godot_rid_new(godot_rid *r_dest); - -godot_int GDAPI godot_rid_get_id(const godot_rid *p_self); - -void GDAPI godot_rid_new_with_resource(godot_rid *r_dest, const godot_object *p_from); - -godot_bool GDAPI godot_rid_operator_equal(const godot_rid *p_self, const godot_rid *p_b); - -godot_bool GDAPI godot_rid_operator_less(const godot_rid *p_self, const godot_rid *p_b); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_RID_H diff --git a/examples/simple/godot_headers/godot/string.h b/examples/simple/godot_headers/godot/string.h deleted file mode 100644 index d4d6d6c..0000000 --- a/examples/simple/godot_headers/godot/string.h +++ /dev/null @@ -1,76 +0,0 @@ -/*************************************************************************/ -/* string.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_STRING_H -#define GODOT_STRING_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#define GODOT_STRING_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_STRING_SIZE]; -} godot_string; -#endif - -#include "gdnative.h" - -void GDAPI godot_string_new(godot_string *r_dest); -void GDAPI godot_string_new_copy(godot_string *r_dest, const godot_string *p_src); -void GDAPI godot_string_new_data(godot_string *r_dest, const char *p_contents, const int p_size); -void GDAPI godot_string_new_unicode_data(godot_string *r_dest, const wchar_t *p_contents, const int p_size); - -void GDAPI godot_string_get_data(const godot_string *p_self, char *p_dest, int *p_size); - -wchar_t GDAPI *godot_string_operator_index(godot_string *p_self, const godot_int p_idx); -const char GDAPI *godot_string_c_str(const godot_string *p_self); -const wchar_t GDAPI *godot_string_unicode_str(const godot_string *p_self); - -godot_bool GDAPI godot_string_operator_equal(const godot_string *p_self, const godot_string *p_b); -godot_bool GDAPI godot_string_operator_less(const godot_string *p_self, const godot_string *p_b); -godot_string GDAPI godot_string_operator_plus(const godot_string *p_self, const godot_string *p_b); - -// @Incomplete -// hmm, I guess exposing the whole API doesn't make much sense -// since the language used in the library has its own string funcs - -void GDAPI godot_string_destroy(godot_string *p_self); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_STRING_H diff --git a/examples/simple/godot_headers/godot/transform.h b/examples/simple/godot_headers/godot/transform.h deleted file mode 100644 index d14190e..0000000 --- a/examples/simple/godot_headers/godot/transform.h +++ /dev/null @@ -1,100 +0,0 @@ -/*************************************************************************/ -/* transform.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_TRANSFORM_H -#define GODOT_TRANSFORM_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_TRANSFORM_SIZE 48 - -#ifndef GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_TRANSFORM_SIZE]; -} godot_transform; -#endif - -#include "basis.h" -#include "gdnative.h" -#include "variant.h" -#include "vector3.h" - -void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin); -void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin); - -godot_basis GDAPI godot_transform_get_basis(const godot_transform *p_self); -void GDAPI godot_transform_set_basis(godot_transform *p_self, godot_basis *p_v); - -godot_vector3 GDAPI godot_transform_get_origin(const godot_transform *p_self); -void GDAPI godot_transform_set_origin(godot_transform *p_self, godot_vector3 *p_v); - -godot_string GDAPI godot_transform_as_string(const godot_transform *p_self); - -godot_transform GDAPI godot_transform_inverse(const godot_transform *p_self); - -godot_transform GDAPI godot_transform_affine_inverse(const godot_transform *p_self); - -godot_transform GDAPI godot_transform_orthonormalized(const godot_transform *p_self); - -godot_transform GDAPI godot_transform_rotated(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi); - -godot_transform GDAPI godot_transform_scaled(const godot_transform *p_self, const godot_vector3 *p_scale); - -godot_transform GDAPI godot_transform_translated(const godot_transform *p_self, const godot_vector3 *p_ofs); - -godot_transform GDAPI godot_transform_looking_at(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up); - -godot_plane GDAPI godot_transform_xform_plane(const godot_transform *p_self, const godot_plane *p_v); - -godot_plane GDAPI godot_transform_xform_inv_plane(const godot_transform *p_self, const godot_plane *p_v); - -void GDAPI godot_transform_new_identity(godot_transform *r_dest); - -godot_bool GDAPI godot_transform_operator_equal(const godot_transform *p_self, const godot_transform *p_b); - -godot_transform GDAPI godot_transform_operator_multiply(const godot_transform *p_self, const godot_transform *p_b); - -godot_vector3 GDAPI godot_transform_xform_vector3(const godot_transform *p_self, const godot_vector3 *p_v); - -godot_vector3 GDAPI godot_transform_xform_inv_vector3(const godot_transform *p_self, const godot_vector3 *p_v); - -godot_rect3 GDAPI godot_transform_xform_rect3(const godot_transform *p_self, const godot_rect3 *p_v); - -godot_rect3 GDAPI godot_transform_xform_inv_rect3(const godot_transform *p_self, const godot_rect3 *p_v); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_TRANSFORM_H diff --git a/examples/simple/godot_headers/godot/transform2d.h b/examples/simple/godot_headers/godot/transform2d.h deleted file mode 100644 index 7171e52..0000000 --- a/examples/simple/godot_headers/godot/transform2d.h +++ /dev/null @@ -1,99 +0,0 @@ -/*************************************************************************/ -/* transform2d.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_TRANSFORM2D_H -#define GODOT_TRANSFORM2D_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_TRANSFORM2D_SIZE 24 - -#ifndef GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_TRANSFORM2D_SIZE]; -} godot_transform2d; -#endif - -#include "gdnative.h" -#include "variant.h" -#include "vector2.h" - -void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos); -void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin); - -godot_string GDAPI godot_transform2d_as_string(const godot_transform2d *p_self); - -godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_self); - -godot_transform2d GDAPI godot_transform2d_affine_inverse(const godot_transform2d *p_self); - -godot_real GDAPI godot_transform2d_get_rotation(const godot_transform2d *p_self); - -godot_vector2 GDAPI godot_transform2d_get_origin(const godot_transform2d *p_self); - -godot_vector2 GDAPI godot_transform2d_get_scale(const godot_transform2d *p_self); - -godot_transform2d GDAPI godot_transform2d_orthonormalized(const godot_transform2d *p_self); - -godot_transform2d GDAPI godot_transform2d_rotated(const godot_transform2d *p_self, const godot_real p_phi); - -godot_transform2d GDAPI godot_transform2d_scaled(const godot_transform2d *p_self, const godot_vector2 *p_scale); - -godot_transform2d GDAPI godot_transform2d_translated(const godot_transform2d *p_self, const godot_vector2 *p_offset); - -godot_vector2 GDAPI godot_transform2d_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); - -godot_vector2 GDAPI godot_transform2d_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); - -godot_vector2 GDAPI godot_transform2d_basis_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); - -godot_vector2 GDAPI godot_transform2d_basis_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); - -godot_transform2d GDAPI godot_transform2d_interpolate_with(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c); - -godot_bool GDAPI godot_transform2d_operator_equal(const godot_transform2d *p_self, const godot_transform2d *p_b); - -godot_transform2d GDAPI godot_transform2d_operator_multiply(const godot_transform2d *p_self, const godot_transform2d *p_b); - -void GDAPI godot_transform2d_new_identity(godot_transform2d *r_dest); - -godot_rect2 GDAPI godot_transform2d_xform_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v); - -godot_rect2 GDAPI godot_transform2d_xform_inv_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_TRANSFORM2D_H diff --git a/examples/simple/godot_headers/godot/variant.h b/examples/simple/godot_headers/godot/variant.h deleted file mode 100644 index b56d582..0000000 --- a/examples/simple/godot_headers/godot/variant.h +++ /dev/null @@ -1,201 +0,0 @@ -/*************************************************************************/ -/* variant.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_VARIANT_H -#define GODOT_VARIANT_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_VARIANT_SIZE 24 - -#ifndef GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_VARIANT_SIZE]; -} godot_variant; -#endif - -typedef enum godot_variant_type { - GODOT_VARIANT_TYPE_NIL, - - // atomic types - GODOT_VARIANT_TYPE_BOOL, - GODOT_VARIANT_TYPE_INT, - GODOT_VARIANT_TYPE_REAL, - GODOT_VARIANT_TYPE_STRING, - - // math types - - GODOT_VARIANT_TYPE_VECTOR2, // 5 - GODOT_VARIANT_TYPE_RECT2, - GODOT_VARIANT_TYPE_VECTOR3, - GODOT_VARIANT_TYPE_TRANSFORM2D, - GODOT_VARIANT_TYPE_PLANE, - GODOT_VARIANT_TYPE_QUAT, // 10 - GODOT_VARIANT_TYPE_RECT3, - GODOT_VARIANT_TYPE_BASIS, - GODOT_VARIANT_TYPE_TRANSFORM, - - // misc types - GODOT_VARIANT_TYPE_COLOR, - GODOT_VARIANT_TYPE_NODE_PATH, // 15 - GODOT_VARIANT_TYPE_RID, - GODOT_VARIANT_TYPE_OBJECT, - GODOT_VARIANT_TYPE_DICTIONARY, - GODOT_VARIANT_TYPE_ARRAY, // 20 - - // arrays - GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY, - GODOT_VARIANT_TYPE_POOL_INT_ARRAY, - GODOT_VARIANT_TYPE_POOL_REAL_ARRAY, - GODOT_VARIANT_TYPE_POOL_STRING_ARRAY, - GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY, // 25 - GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY, - GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY, -} godot_variant_type; - -typedef enum godot_variant_call_error_error { - GODOT_CALL_ERROR_CALL_OK, - GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD, - GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT, - GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS, - GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS, - GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL, -} godot_variant_call_error_error; - -typedef struct godot_variant_call_error { - godot_variant_call_error_error error; - int argument; - godot_variant_type expected; -} godot_variant_call_error; - -#include "array.h" -#include "basis.h" -#include "color.h" -#include "dictionary.h" -#include "node_path.h" -#include "plane.h" -#include "pool_arrays.h" -#include "quat.h" -#include "rect2.h" -#include "rect3.h" -#include "rid.h" -#include "string.h" -#include "transform.h" -#include "transform2d.h" -#include "variant.h" -#include "vector2.h" -#include "vector3.h" - -#include "gdnative.h" - -godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v); - -void GDAPI godot_variant_new_copy(godot_variant *r_dest, const godot_variant *p_src); - -void GDAPI godot_variant_new_nil(godot_variant *r_dest); - -void GDAPI godot_variant_new_bool(godot_variant *p_v, const godot_bool p_b); -void GDAPI godot_variant_new_uint(godot_variant *r_dest, const uint64_t p_i); -void GDAPI godot_variant_new_int(godot_variant *r_dest, const int64_t p_i); -void GDAPI godot_variant_new_real(godot_variant *r_dest, const double p_r); -void GDAPI godot_variant_new_string(godot_variant *r_dest, const godot_string *p_s); -void GDAPI godot_variant_new_vector2(godot_variant *r_dest, const godot_vector2 *p_v2); -void GDAPI godot_variant_new_rect2(godot_variant *r_dest, const godot_rect2 *p_rect2); -void GDAPI godot_variant_new_vector3(godot_variant *r_dest, const godot_vector3 *p_v3); -void GDAPI godot_variant_new_transform2d(godot_variant *r_dest, const godot_transform2d *p_t2d); -void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_plane); -void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat); -void GDAPI godot_variant_new_rect3(godot_variant *r_dest, const godot_rect3 *p_rect3); -void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis); -void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans); -void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color); -void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np); -void GDAPI godot_variant_new_rid(godot_variant *r_dest, const godot_rid *p_rid); -void GDAPI godot_variant_new_object(godot_variant *r_dest, const godot_object *p_obj); -void GDAPI godot_variant_new_dictionary(godot_variant *r_dest, const godot_dictionary *p_dict); -void GDAPI godot_variant_new_array(godot_variant *r_dest, const godot_array *p_arr); -void GDAPI godot_variant_new_pool_byte_array(godot_variant *r_dest, const godot_pool_byte_array *p_pba); -void GDAPI godot_variant_new_pool_int_array(godot_variant *r_dest, const godot_pool_int_array *p_pia); -void GDAPI godot_variant_new_pool_real_array(godot_variant *r_dest, const godot_pool_real_array *p_pra); -void GDAPI godot_variant_new_pool_string_array(godot_variant *r_dest, const godot_pool_string_array *p_psa); -void GDAPI godot_variant_new_pool_vector2_array(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a); -void GDAPI godot_variant_new_pool_vector3_array(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a); -void GDAPI godot_variant_new_pool_color_array(godot_variant *r_dest, const godot_pool_color_array *p_pca); - -godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_self); -uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_self); -int64_t GDAPI godot_variant_as_int(const godot_variant *p_self); -double GDAPI godot_variant_as_real(const godot_variant *p_self); -godot_string GDAPI godot_variant_as_string(const godot_variant *p_self); -godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_self); -godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_self); -godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_self); -godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_self); -godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self); -godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self); -godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_self); -godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self); -godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self); -godot_color GDAPI godot_variant_as_color(const godot_variant *p_self); -godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self); -godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_self); -godot_object GDAPI *godot_variant_as_object(const godot_variant *p_self); -godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_self); -godot_array GDAPI godot_variant_as_array(const godot_variant *p_self); -godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_self); -godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_self); -godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_self); -godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_self); -godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_self); -godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_self); -godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_self); - -godot_variant GDAPI godot_variant_call(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error); - -godot_bool GDAPI godot_variant_has_method(const godot_variant *p_self, const godot_string *p_method); - -godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_self, const godot_variant *p_other); -godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_self, const godot_variant *p_other); - -godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_self, const godot_variant *p_other); - -godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_self, godot_bool *r_valid); - -void GDAPI godot_variant_destroy(godot_variant *p_self); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/examples/simple/godot_headers/godot/vector2.h b/examples/simple/godot_headers/godot/vector2.h deleted file mode 100644 index 9934dda..0000000 --- a/examples/simple/godot_headers/godot/vector2.h +++ /dev/null @@ -1,128 +0,0 @@ -/*************************************************************************/ -/* vector2.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_VECTOR2_H -#define GODOT_VECTOR2_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_VECTOR2_SIZE 8 - -#ifndef GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_VECTOR2_SIZE]; -} godot_vector2; -#endif - -#include "gdnative.h" - -void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y); - -godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self); - -godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_self); - -godot_real GDAPI godot_vector2_length(const godot_vector2 *p_self); - -godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_self); - -godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_self); - -godot_bool GDAPI godot_vector2_is_normalized(const godot_vector2 *p_self); - -godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_self, const godot_vector2 *p_to); - -godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_self, const godot_vector2 *p_to); - -godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot_vector2 *p_to); - -godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to); - -godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t); - -godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t); - -godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_self, const godot_real p_phi); - -godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_self); - -godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_self); - -godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_self, const godot_vector2 *p_by); - -godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_self); - -godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_self, const godot_vector2 *p_with); - -godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_self, const godot_vector2 *p_n); - -godot_vector2 GDAPI godot_vector2_bounce(const godot_vector2 *p_self, const godot_vector2 *p_n); - -godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_self, const godot_vector2 *p_n); - -godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_self); - -godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_self, const godot_real p_length); - -godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_self, const godot_vector2 *p_b); - -godot_vector2 GDAPI godot_vector2_operator_substract(const godot_vector2 *p_self, const godot_vector2 *p_b); - -godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_self, const godot_vector2 *p_b); - -godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_self, const godot_real p_b); - -godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_self, const godot_vector2 *p_b); - -godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_self, const godot_real p_b); - -godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_self, const godot_vector2 *p_b); - -godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_self, const godot_vector2 *p_b); - -godot_vector2 GDAPI godot_vector2_operator_neg(const godot_vector2 *p_self); - -void GDAPI godot_vector2_set_x(godot_vector2 *p_self, const godot_real p_x); - -void GDAPI godot_vector2_set_y(godot_vector2 *p_self, const godot_real p_y); - -godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_self); - -godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_self); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_VECTOR2_H diff --git a/examples/simple/godot_headers/godot/vector3.h b/examples/simple/godot_headers/godot/vector3.h deleted file mode 100644 index b5f8d0f..0000000 --- a/examples/simple/godot_headers/godot/vector3.h +++ /dev/null @@ -1,135 +0,0 @@ -/*************************************************************************/ -/* vector3.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_VECTOR3_H -#define GODOT_VECTOR3_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#define GODOT_VECTOR3_SIZE 12 - -#ifndef GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED -#define GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED -typedef struct { - uint8_t _dont_touch_that[GODOT_VECTOR3_SIZE]; -} godot_vector3; -#endif - -#include "basis.h" -#include "gdnative.h" - -typedef enum { - GODOT_VECTOR3_AXIS_X, - GODOT_VECTOR3_AXIS_Y, - GODOT_VECTOR3_AXIS_Z, -} godot_vector3_axis; - -void GDAPI godot_vector3_new(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z); - -godot_string GDAPI godot_vector3_as_string(const godot_vector3 *p_self); - -godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_self); - -godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_self); - -godot_real GDAPI godot_vector3_length(const godot_vector3 *p_self); - -godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_self); - -godot_bool GDAPI godot_vector3_is_normalized(const godot_vector3 *p_self); - -godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_self); - -godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_self); - -godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const godot_vector3 *p_by); - -godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi); - -godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t); - -godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t); - -godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_self); - -godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_self); - -godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_self); - -godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_self); - -godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_self, const godot_vector3 *p_to); - -godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_self, const godot_vector3 *p_n); - -godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_self, const godot_vector3 *p_n); - -godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_self, const godot_vector3 *p_n); - -godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_vector3 GDAPI godot_vector3_operator_substract(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_self, const godot_real p_b); - -godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_self, const godot_real p_b); - -godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_self, const godot_vector3 *p_b); - -godot_vector3 GDAPI godot_vector3_operator_neg(const godot_vector3 *p_self); - -void GDAPI godot_vector3_set_axis(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val); - -godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_self, const godot_vector3_axis p_axis); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_VECTOR3_H diff --git a/examples/simple/godot_headers/godot_nativescript.h b/examples/simple/godot_headers/godot_nativescript.h deleted file mode 100644 index 9a84899..0000000 --- a/examples/simple/godot_headers/godot_nativescript.h +++ /dev/null @@ -1,228 +0,0 @@ -/*************************************************************************/ -/* godot.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_NATIVESCRIPT_H -#define GODOT_NATIVESCRIPT_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef GDAPI_BUILT_IN -#define GDAPI_EXPORT -#endif - -#ifdef _WIN32 -#if defined(GDAPI_EXPORT) -#define GDCALLINGCONV -#define GDAPI __declspec(dllexport) GDCALLINGCONV -#else -#define GDCALLINGCONV -#define GDAPI __declspec(dllimport) GDCALLINGCONV -#endif -#elif defined(__APPLE__) -#include "TargetConditionals.h" -#if TARGET_OS_IPHONE -#define GDCALLINGCONV -#define GDAPI -#elif TARGET_OS_MAC -#define GDCALLINGCONV __attribute__((sysv_abi)) -#define GDAPI GDCALLINGCONV -#endif -#else -#define GDCALLINGCONV __attribute__((sysv_abi)) -#define GDAPI GDCALLINGCONV -#endif - -// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!! -#ifdef _WIN32 -#define GDN_EXPORT __declspec(dllexport) -#else -#define GDN_EXPORT -#endif - -#include -#include - -typedef enum { - GODOT_METHOD_RPC_MODE_DISABLED, - GODOT_METHOD_RPC_MODE_REMOTE, - GODOT_METHOD_RPC_MODE_SYNC, - GODOT_METHOD_RPC_MODE_MASTER, - GODOT_METHOD_RPC_MODE_SLAVE, -} godot_method_rpc_mode; - -typedef enum { - GODOT_PROPERTY_HINT_NONE, ///< no hint provided. - GODOT_PROPERTY_HINT_RANGE, ///< hint_text = "min,max,step,slider; //slider is optional" - GODOT_PROPERTY_HINT_EXP_RANGE, ///< hint_text = "min,max,step", exponential edit - GODOT_PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc" - GODOT_PROPERTY_HINT_EXP_EASING, /// exponential easing funciton (Math::ease) - GODOT_PROPERTY_HINT_LENGTH, ///< hint_text= "length" (as integer) - GODOT_PROPERTY_HINT_SPRITE_FRAME, - GODOT_PROPERTY_HINT_KEY_ACCEL, ///< hint_text= "length" (as integer) - GODOT_PROPERTY_HINT_FLAGS, ///< hint_text= "flag1,flag2,etc" (as bit flags) - GODOT_PROPERTY_HINT_LAYERS_2D_RENDER, - GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS, - GODOT_PROPERTY_HINT_LAYERS_3D_RENDER, - GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS, - GODOT_PROPERTY_HINT_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," - GODOT_PROPERTY_HINT_DIR, ///< a directort path must be passed - GODOT_PROPERTY_HINT_GLOBAL_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc," - GODOT_PROPERTY_HINT_GLOBAL_DIR, ///< a directort path must be passed - GODOT_PROPERTY_HINT_RESOURCE_TYPE, ///< a resource object type - GODOT_PROPERTY_HINT_MULTILINE_TEXT, ///< used for string properties that can contain multiple lines - GODOT_PROPERTY_HINT_COLOR_NO_ALPHA, ///< used for ignoring alpha component when editing a color - GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY, - GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS, - GODOT_PROPERTY_HINT_OBJECT_ID, - GODOT_PROPERTY_HINT_TYPE_STRING, ///< a type string, the hint is the base type to choose - GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE, ///< so something else can provide this (used in scripts) - GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE, ///< a method of a type - GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE, ///< a method of a base type - GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE, ///< a method of an instance - GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT, ///< a method of a script & base - GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE, ///< a property of a type - GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE, ///< a property of a base type - GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE, ///< a property of an instance - GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT, ///< a property of a script & base - GODOT_PROPERTY_HINT_MAX, -} godot_property_hint; - -typedef enum { - - GODOT_PROPERTY_USAGE_STORAGE = 1, - GODOT_PROPERTY_USAGE_EDITOR = 2, - GODOT_PROPERTY_USAGE_NETWORK = 4, - GODOT_PROPERTY_USAGE_EDITOR_HELPER = 8, - GODOT_PROPERTY_USAGE_CHECKABLE = 16, //used for editing global variables - GODOT_PROPERTY_USAGE_CHECKED = 32, //used for editing global variables - GODOT_PROPERTY_USAGE_INTERNATIONALIZED = 64, //hint for internationalized strings - GODOT_PROPERTY_USAGE_GROUP = 128, //used for grouping props in the editor - GODOT_PROPERTY_USAGE_CATEGORY = 256, - GODOT_PROPERTY_USAGE_STORE_IF_NONZERO = 512, //only store if nonzero - GODOT_PROPERTY_USAGE_STORE_IF_NONONE = 1024, //only store if false - GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE = 2048, - GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED = 4096, - GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE = 8192, - GODOT_PROPERTY_USAGE_STORE_IF_NULL = 16384, - GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER = 32768, - GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 65536, - - GODOT_PROPERTY_USAGE_DEFAULT = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK, - GODOT_PROPERTY_USAGE_DEFAULT_INTL = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK | GODOT_PROPERTY_USAGE_INTERNATIONALIZED, - GODOT_PROPERTY_USAGE_NOEDITOR = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_NETWORK, -} godot_property_usage_flags; - -typedef struct { - godot_method_rpc_mode rset_type; - - godot_int type; - godot_property_hint hint; - godot_string hint_string; - godot_property_usage_flags usage; - godot_variant default_value; -} godot_property_attributes; - -typedef struct { - // instance pointer, method_data - return user data - GDCALLINGCONV void *(*create_func)(godot_object *, void *); - void *method_data; - GDCALLINGCONV void (*free_func)(void *); -} godot_instance_create_func; - -typedef struct { - // instance pointer, method data, user data - GDCALLINGCONV void (*destroy_func)(godot_object *, void *, void *); - void *method_data; - GDCALLINGCONV void (*free_func)(void *); -} godot_instance_destroy_func; - -void GDAPI godot_nativescript_register_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func); - -void GDAPI godot_nativescript_register_tool_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func); - -typedef struct { - godot_method_rpc_mode rpc_type; -} godot_method_attributes; - -typedef struct { - // instance pointer, method data, user data, num args, args - return result as varaint - GDCALLINGCONV godot_variant (*method)(godot_object *, void *, void *, int, godot_variant **); - void *method_data; - GDCALLINGCONV void (*free_func)(void *); -} godot_instance_method; - -void GDAPI godot_nativescript_register_method(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method); - -typedef struct { - // instance pointer, method data, user data, value - GDCALLINGCONV void (*set_func)(godot_object *, void *, void *, godot_variant *); - void *method_data; - GDCALLINGCONV void (*free_func)(void *); -} godot_property_set_func; - -typedef struct { - // instance pointer, method data, user data, value - GDCALLINGCONV godot_variant (*get_func)(godot_object *, void *, void *); - void *method_data; - GDCALLINGCONV void (*free_func)(void *); -} godot_property_get_func; - -void GDAPI godot_nativescript_register_property(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func); - -typedef struct { - godot_string name; - godot_int type; - godot_property_hint hint; - godot_string hint_string; - godot_property_usage_flags usage; - godot_variant default_value; -} godot_signal_argument; - -typedef struct { - godot_string name; - int num_args; - godot_signal_argument *args; - int num_default_args; - godot_variant *default_args; -} godot_signal; - -void GDAPI godot_nativescript_register_signal(void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal); -godot_object GDAPI *godot_nativescript_new(const char *p_classname); - -void GDAPI *godot_nativescript_get_userdata(godot_object *p_instance); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/examples/simple/src/nim.cfg b/examples/simple/src/nim.cfg index 7e8f842..a64088d 100644 --- a/examples/simple/src/nim.cfg +++ b/examples/simple/src/nim.cfg @@ -1,6 +1,5 @@ --path:"$projectdir" --path:"$projectdir/../godotapi" ---cincludes:"$projectdir/../godot_headers/" --experimental --app:lib --stackTrace:on diff --git a/examples/simple/src/simple.nimble b/examples/simple/src/simple.nimble index f33fa69..22c3f19 100644 --- a/examples/simple/src/simple.nimble +++ b/examples/simple/src/simple.nimble @@ -1,10 +1,10 @@ version = "0.1.0" author = "Xored Software, Inc." -description = "FPS Counter Sample" +description = "Simple Sample" license = "MIT" bin = @["simple"] -requires "https://github.com/pragmagic/godot-nim.git >= 0.2.3 & < 0.3.0" +requires "https://github.com/pragmagic/godot-nim.git >= 0.3.0 & < 0.4.0" task make, "build": const archPostfix = when sizeof(int) == 8: "_64" else: "_32" diff --git a/godot.nimble b/godot.nimble index 371275f..1788bf7 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.2.4" +version = "0.3.0" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 8d1f054..fcc065b 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -4,28 +4,21 @@ import hashes import godotbase, poolarray, variant, strings proc initArray(dest: var Array) {. - importc: "godot_array_new", header: "godot/array.h".} + importc: "godot_array_new".} proc initArray(dest: var Array; pca: PoolColorArray) {. - importc: "godot_array_new_pool_coloarray", - header: "godot/array.h".} + importc: "godot_array_new_pool_coloarray".} proc initArray(dest: var Array; pv3a: PoolVector3Array) {. - importc: "godot_array_new_pool_vector3_array", - header: "godot/array.h".} + importc: "godot_array_new_pool_vector3_array".} proc initArray(dest: var Array; pv2a: PoolVector2Array) {. - importc: "godot_array_new_pool_vector2_array", - header: "godot/array.h".} + importc: "godot_array_new_pool_vector2_array".} proc initArray(dest: var Array; psa: PoolStringArray) {. - importc: "godot_array_new_pool_string_array", - header: "godot/array.h".} + importc: "godot_array_new_pool_string_array".} proc initArray(dest: var Array; pra: PoolRealArray) {. - importc: "godot_array_new_pool_real_array", - header: "godot/array.h".} + importc: "godot_array_new_pool_real_array".} proc initArray(dest: var Array; pia: PoolIntArray) {. - importc: "godot_array_new_pool_int_array", - header: "godot/array.h".} + importc: "godot_array_new_pool_int_array".} proc initArray(dest: var Array; pba: PoolByteArray) {. - importc: "godot_array_new_pool_byte_array", - header: "godot/array.h".} + importc: "godot_array_new_pool_byte_array".} proc initArray*(): Array {.inline.} = initArray(result) @@ -54,79 +47,76 @@ proc initArray*(pba: PoolByteArray): Array {.inline.} = proc `[]=`*(self: var Array; idx: cint; value: Variant) {. noSideEffect, - importc: "godot_array_set", header: "godot/array.h".} + importc: "godot_array_set".} proc `[]`*(self: Array; idx: cint): Variant {. noSideEffect, - importc: "godot_array_get", header: "godot/array.h".} + importc: "godot_array_get".} proc mget*(self: var Array; idx: cint): ptr Variant {. - importc: "godot_array_operator_index", header: "godot/array.h".} + importc: "godot_array_operator_index".} proc add*(self: var Array; value: Variant) {. noSideEffect, - importc: "godot_array_append", header: "godot/array.h".} -proc clear*(self: var Array) {.importc: "godot_array_clear", - header: "godot/array.h".} + importc: "godot_array_append".} +proc clear*(self: var Array) {.importc: "godot_array_clear".} proc count*(self: Array; value: Variant): cint {. noSideEffect, - importc: "godot_array_count", header: "godot/array.h".} + importc: "godot_array_count".} proc isEmpty*(self: Array): bool {. noSideEffect, - importc: "godot_array_empty", header: "godot/array.h".} + importc: "godot_array_empty".} proc erase*(self: var Array; value: Variant) {. - importc: "godot_array_erase", header: "godot/array.h".} + importc: "godot_array_erase".} proc first*(self: Array): Variant {. noSideEffect, - importc: "godot_array_front", header: "godot/array.h".} + importc: "godot_array_front".} proc last*(self: Array): Variant {. noSideEffect, - importc: "godot_array_back", header: "godot/array.h".} + importc: "godot_array_back".} proc find*(self: Array; what: Variant; f: cint): cint {. noSideEffect, - importc: "godot_array_find", header: "godot/array.h".} + importc: "godot_array_find".} proc findLast*(self: Array; what: Variant): cint {. noSideEffect, - importc: "godot_array_find_last", header: "godot/array.h".} + importc: "godot_array_find_last".} proc contains*(self: Array; value: Variant): bool {. noSideEffect, - importc: "godot_array_has", header: "godot/array.h".} + importc: "godot_array_has".} proc godotHash*(self: Array): cint {. noSideEffect, - importc: "godot_array_hash", header: "godot/array.h".} + importc: "godot_array_hash".} proc hash*(self: Array): Hash {.inline.} = hash(godotHash(self)) proc insert*(self: var Array; pos: cint; value: Variant) {. - importc: "godot_array_insert", header: "godot/array.h".} -proc reverse*(self: var Array) {.importc: "godot_array_invert", - header: "godot/array.h".} + importc: "godot_array_insert".} +proc reverse*(self: var Array) {.importc: "godot_array_invert".} proc popLast*(self: var Array): Variant {. - importc: "godot_array_pop_back", header: "godot/array.h".} + importc: "godot_array_pop_back".} proc popFirst*(self: var Array): Variant {. - importc: "godot_array_pop_front", header: "godot/array.h".} + importc: "godot_array_pop_front".} proc addLast*(self: var Array; value: Variant) {. - importc: "godot_array_push_back", header: "godot/array.h".} + importc: "godot_array_push_back".} proc addFirst*(self: var Array; value: Variant) {. - importc: "godot_array_push_front", header: "godot/array.h".} + importc: "godot_array_push_front".} proc delete*(self: var Array; idx: cint) {. - importc: "godot_array_remove", header: "godot/array.h".} + importc: "godot_array_remove".} proc setLen*(self: var Array; size: cint) {. - importc: "godot_array_resize", header: "godot/array.h".} + importc: "godot_array_resize".} proc rfind*(self: Array; what: Variant; f: cint): cint {. noSideEffect, - importc: "godot_array_rfind", header: "godot/array.h".} + importc: "godot_array_rfind".} proc len*(self: Array): cint {. noSideEffect, - importc: "godot_array_size", header: "godot/array.h".} -proc sort*(self: var Array) {.importc: "godot_array_sort", - header: "godot/array.h".} + importc: "godot_array_size".} +proc sort*(self: var Array) {.importc: "godot_array_sort".} proc sortCustom*(self: var Array; obj: var GodotObject; funcName: GodotString) {. - importc: "godot_array_sort_custom", header: "godot/array.h".} + importc: "godot_array_sort_custom".} iterator items*(arr: Array): Variant = for i in 0.. -PI * 0.5: + result.x = arctan2(-self.elements[1].z, self.elements[2].z) + result.z = arctan2(-self.elements[0].y, self.elements[0].x) + else: + let r = arctan2(self.elements[1].x, self.elements[1].y) + result.x = -r + else: + let r = arctan2(self.elements[0].y, self.elements[1].y) + result.x = r proc initBasis*(euler: Vector3): Basis {.inline.} = - initBasis(result, euler) + result.setEuler(euler) -proc toGodotString*(self: Basis): GodotString {. - noSideEffect, - importc: "godot_basis_as_string", header: "godot/basis.h".} +proc outer*(self, other: Vector3): Basis {.inline.} = + let row0 = vec3(self.x * other.x, self.x * other.y, self.x * other.z) + let row1 = vec3(self.y * other.x, self.y * other.y, self.y * other.z) + let row2 = vec3(self.z * other.x, self.z * other.y, self.z * other.z) + initBasis(row0, row1, row2) + +proc toDiagonalMatrix*(self: Vector3): Basis {.inline.} = + initBasis( + self.x, 0, 0, + 0, self.y, 0, + 0, 0, self.z + ) proc `$`*(self: Basis): string {.inline.} = - $self.toGodotString() + result = newStringOfCap(128) + for i in 0..2: + for j in 0..2: + if i != 0 or j != 0: + result.add(", ") + result.add($self[i][j]) -proc inverse*(self: Basis): Basis {. - noSideEffect, - importc: "godot_basis_inverse", header: "godot/basis.h".} -proc transposed*(self: Basis): Basis {. - noSideEffect, - importc: "godot_basis_transposed", header: "godot/basis.h".} -proc orthonormalized*(self: Basis): Basis {. - noSideEffect, - importc: "godot_basis_orthonormalized", header: "godot/basis.h".} -proc determinant*(self: Basis): float32 {. - noSideEffect, - importc: "godot_basis_determinant", header: "godot/basis.h".} -proc rotated*(self: Basis; axis: Vector3; - phi: float32): Basis {. - noSideEffect, - importc: "godot_basis_rotated", header: "godot/basis.h".} -proc scaled*(self: Basis; scale: Vector3): Basis {. - noSideEffect, - importc: "godot_basis_scaled", header: "godot/basis.h".} +template cofac(row1, col1, row2, col2: int): float32 = + self.elements[row1][col1] * self.elements[row2][col2] - + self.elements[row1][col2] * self.elements[row2][col1] -proc setScale*(self: var Basis; scale: Vector3) {. - noSideEffect, - importc: "godot_basis_set_scale", header: "godot/basis.h".} -proc setRotationEuler*(self: var Basis; - euler: Vector3) {. - noSideEffect, - importc: "godot_basis_set_rotation_euler", header: "godot/basis.h".} -proc setRotationAxisAngle*(self: var Basis; axis: Vector3; angle: float32) {. - noSideEffect, - importc: "godot_basis_set_rotation_axis_angle", header: "godot/basis.h".} +proc determinant(self: Basis): float32 {.inline.} = + self[0][0] * cofac(1, 1, 2, 2) - + self[1][0] * cofac(0, 1, 2, 2) + + self[2][0] * cofac(0, 1, 1, 2) -proc scale*(self: Basis): Vector3 {. - noSideEffect, - importc: "godot_basis_get_scale", header: "godot/basis.h".} -proc euler*(self: Basis): Vector3 {. - noSideEffect, - importc: "godot_basis_get_euler", header: "godot/basis.h".} +proc invert*(self: var Basis) = + let co = [cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1)] + let det = self.elements[0][0] * co[0] + + self.elements[0][1] * co[1] + + self.elements[0][2] * co[2] + assert(det != 0) + let s = 1.0'f32 / det + self.setCells( + co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s, + co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s, + co[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s + ) -proc tdotx*(self: Basis; x: Vector3): float32 {. - noSideEffect, - importc: "godot_basis_tdotx", header: "godot/basis.h".} -proc tdoty*(self: Basis; y: Vector3): float32 {. - noSideEffect, - importc: "godot_basis_tdoty", header: "godot/basis.h".} -proc tdotz*(self: Basis; z: Vector3): float32 {. - noSideEffect, - importc: "godot_basis_tdotz", header: "godot/basis.h".} +proc inverse*(self: Basis): Basis {.inline.} = + result = self + result.invert() -proc xform*(self: Basis; v: Vector3): Vector3 {. - noSideEffect, - importc: "godot_basis_xform", header: "godot/basis.h".} -proc xformInv*(self: Basis; v: Vector3): Vector3 {. - noSideEffect, - importc: "godot_basis_xform_inv", header: "godot/basis.h".} +proc axis*(self: Basis; idx: range[0..2]): Vector3 {.inline.} = + vec3(self[0][idx], self[1][idx], self[2][idx]) -proc orthogonalIndex*(self: Basis): cint {. - noSideEffect, - importc: "godot_basis_get_orthogonal_index", header: "godot/basis.h".} +proc setAxis*(self: var Basis; idx: range[0..2]; value: Vector3) {.inline.} = + self.elements[0][idx] = value.x + self.elements[1][idx] = value.y + self.elements[2][idx] = value.z -proc godot_basis_get_elements(self: Basis; - elements: var array[3, Vector3]) {. - noSideEffect, - importc: "godot_basis_get_elements", header: "godot/basis.h".} +proc row*(self: Basis; row: range[0..2]): Vector3 {.inline.} = + self.elements[row] -proc elements*(self: Basis): array[3, Vector3] {.inline.} = - godot_basis_get_elements(self, result) +proc setRow*(self: var Basis; row: range[0..2]; value: Vector3) {.inline.} = + self.elements[row] = value -proc `[]`*(self: Basis; axis: range[0..2]): Vector3 {. - noSideEffect, - importc: "godot_basis_get_axis", header: "godot/basis.h".} -proc `[]=`*(self: var Basis; axis: range[0..2]; - value: Vector3) {. - noSideEffect, - importc: "godot_basis_set_axis", header: "godot/basis.h".} -proc row*(self: Basis; row: cint): Vector3 {. - noSideEffect, - importc: "godot_basis_get_row", header: "godot/basis.h".} -proc setRow*(self: var Basis; row: cint; - value: Vector3) {. - noSideEffect, - importc: "godot_basis_set_row", header: "godot/basis.h".} -proc `==`*(self: Basis; b: Basis): bool {. - noSideEffect, - importc: "godot_basis_operator_equal", header: "godot/basis.h".} -proc `+`*(self: Basis; b: Basis): Basis {. - noSideEffect, - importc: "godot_basis_operator_add", header: "godot/basis.h".} -proc `-`*(self: Basis; b: Basis): Basis {. - noSideEffect, - importc: "godot_basis_operator_substract", header: "godot/basis.h".} -proc `*`*(self: Basis; b: Basis): Basis {. - noSideEffect, - importc: "godot_basis_operator_multiply_vector", header: "godot/basis.h".} -proc `*`*(self: Basis; b: float32): Basis {. - noSideEffect, - importc: "godot_basis_operator_multiply_scalar", header: "godot/basis.h".} +proc getMainDiagonal*(self: Basis): Vector3 {.inline.} = + vec3(self.elements[0][0], self.elements[1][1], self.elements[2][2]) + +proc zero*(self: var Basis) {.inline.} = + self.elements[0].zero() + self.elements[1].zero() + self.elements[2].zero() + +proc orthonormalize(self: var Basis) = + var x = self.axis(0) + var y = self.axis(1) + var z = self.axis(2) + + x.normalize() + y = y - x * x.dot(y) + y.normalize() + z = z - x * x.dot(z) - y * y.dot(z) + z.normalize() + + self.setAxis(0, x) + self.setAxis(1, y) + self.setAxis(2, z) + +proc orthonormalized*(self: Basis): Basis {.inline.} = + result = self + result.orthonormalize() + +proc transpose*(self: var Basis) {.inline.} = + swap(self.elements[0].x, self.elements[1].x) + swap(self.elements[0].z, self.elements[2].x) + swap(self.elements[1].z, self.elements[2].y) + +proc transposed*(self: Basis): Basis {.inline.} = + result = self + result.transpose() + +proc isOrthogonal*(self: Basis): bool {.inline.} = + let id = initBasis() + let m = self * self.transposed() + result = id.isEqualApprox(m) + +proc isRotation*(self: Basis): bool {.inline.} = + self.determinant().isEqualApprox(1.0) and self.isOrthogonal() + +proc isSymmetric*(self: Basis): bool {.inline.} = + if not self.elements[0][1].isEqualApprox(self.elements[1][0]): + return false + if not self.elements[0][2].isEqualApprox(self.elements[2][0]): + return false + if not self.elements[1][2].isEqualApprox(self.elements[2][1]): + return false + result = true + +proc scale*(self: var Basis, scale: Vector3) = + self[0].x *= scale.x + self[0].y *= scale.x + self[0].z *= scale.x + self[1].x *= scale.y + self[1].y *= scale.y + self[1].z *= scale.y + self[2].x *= scale.z + self[2].y *= scale.z + self[2].z *= scale.z + +proc scaled*(self: Basis, scale: Vector3): Basis = + result = self + result.scale(scale) + +proc rotated*(self: Basis; axis: Vector3; phi: float32): Basis {.inline.} = + initBasis(axis, phi) * self + +proc rotate*(self: var Basis; axis: Vector3; phi: float32) {.inline.} = + self = self.rotated(axis, phi) + +proc rotated*(self: Basis; euler: Vector3): Basis {.inline.} = + initBasis(euler) * self + +proc rotate*(self: var Basis; euler: Vector3) {.inline.} = + self = self.rotated(euler) + +proc getScale*(self: Basis): Vector3 = + let detSign = if self.determinant() > 0: 1'f32 else: -1'f32 + result = detSign * vec3( + vec3(self.elements[0].x, self.elements[1].x, self.elements[2].x).length(), + vec3(self.elements[0].y, self.elements[1].y, self.elements[2].y).length(), + vec3(self.elements[0].z, self.elements[1].z, self.elements[2].z).length(), + ) + +proc getRotation*(self: Basis): Vector3 {.inline.} = + var m = self.orthonormalized() + let det = m.determinant() + if det < 0: + m.scale(vec3(-1, -1, -1)) + result = m.getEuler() + +proc setScale*(self: var Basis; scale: Vector3) = + let e = self.getEuler() + self = initBasis() # reset to identity + self.scale(scale) + self.rotate(e) + +proc setRotationEuler*(self: var Basis; euler: Vector3) = + let s = self.getScale() + self = initBasis() + self.scale(s) + self.rotate(euler) + +proc setRotationAxisAngle*(self: var Basis; axis: Vector3; angle: float32) = + let s = self.getScale() + self = initBasis() + self.scale(s) + self.rotate(axis, angle) + +proc asQuat*(self: Basis): Quat = + let trace = self.elements[0].x + self.elements[1].y + self.elements[2].z + var temp: array[4, float32] + if trace > 0'f32: + var s = sqrt(trace + 1.0) + temp[3] = s * 0.5 + s = 0.5 / s + + temp[0] = (self.elements[2].y - self.elements[1].z) * s + temp[1] = (self.elements[0].z - self.elements[2].x) * s + temp[2] = (self.elements[1].x - self.elements[0].y) * s + else: + let i = if self.elements[0].x < self.elements[1].y: + if self.elements[1].y < self.elements[2].z: 2 else: 1 + else: + if self.elements[0].x < self.elements[2].z: 2 else: 0 + let j = (i + 1) mod 3 + let k = (i + 2) mod 3 + + var s = sqrt(self.elements[i][i] - self.elements[j][j] - + self.elements[k][k] + 1.0) + temp[i] = s * 0.5 + s = 0.5 / s + + temp[3] = (self.elements[k][j] - self.elements[j][k]) * s + temp[j] = (self.elements[j][i] + self.elements[i][j]) * s + temp[k] = (self.elements[k][i] + self.elements[i][k]) * s + + result = initQuat(temp[0], temp[1], temp[2], temp[3]) + +proc xform*(self: Basis; v: Vector3): Vector3 {.inline.} = + vec3( + self.elements[0].dot(v), + self.elements[1].dot(v), + self.elements[2].dot(v) + ) + +proc xformInv*(self: Basis; v: Vector3): Vector3 {.inline.} = + vec3( + self.elements[0].x * v.x + self.elements[1].x * v.y + self.elements[2].x * v.z, + self.elements[0].y * v.x + self.elements[1].y * v.y + self.elements[2].y * v.z, + self.elements[0].z * v.x + self.elements[1].z * v.y + self.elements[2].z * v.z, + ) + +const orthoBases = [ + initBasis(1, 0, 0, 0, 1, 0, 0, 0, 1), + initBasis(0, -1, 0, 1, 0, 0, 0, 0, 1), + initBasis(-1, 0, 0, 0, -1, 0, 0, 0, 1), + initBasis(0, 1, 0, -1, 0, 0, 0, 0, 1), + initBasis(1, 0, 0, 0, 0, -1, 0, 1, 0), + initBasis(0, 0, 1, 1, 0, 0, 0, 1, 0), + initBasis(-1, 0, 0, 0, 0, 1, 0, 1, 0), + initBasis(0, 0, -1, -1, 0, 0, 0, 1, 0), + initBasis(1, 0, 0, 0, -1, 0, 0, 0, -1), + initBasis(0, 1, 0, 1, 0, 0, 0, 0, -1), + initBasis(-1, 0, 0, 0, 1, 0, 0, 0, -1), + initBasis(0, -1, 0, -1, 0, 0, 0, 0, -1), + initBasis(1, 0, 0, 0, 0, 1, 0, -1, 0), + initBasis(0, 0, -1, 1, 0, 0, 0, -1, 0), + initBasis(-1, 0, 0, 0, 0, -1, 0, -1, 0), + initBasis(0, 0, 1, -1, 0, 0, 0, -1, 0), + initBasis(0, 0, 1, 0, 1, 0, -1, 0, 0), + initBasis(0, -1, 0, 0, 0, 1, -1, 0, 0), + initBasis(0, 0, -1, 0, -1, 0, -1, 0, 0), + initBasis(0, 1, 0, 0, 0, -1, -1, 0, 0), + initBasis(0, 0, 1, 0, -1, 0, 1, 0, 0), + initBasis(0, 1, 0, 0, 0, 1, 1, 0, 0), + initBasis(0, 0, -1, 0, 1, 0, 1, 0, 0), + initBasis(0, -1, 0, 0, 0, -1, 1, 0, 0) +] + +proc orthogonalIndex*(self: Basis): int = + var orth = self + for i in 0..2: + for j in 0..2: + var v = orth[i][j] + if v > 0.5: + v = 1.0'f32 + elif v < -0.5: + v = -1.0'f32 + else: + v = 0'f32 + orth[i][j] = v + + for idx, base in orthoBases: + if base == orth: + return idx + +proc setOrthogonalIndex*(self: var Basis, idx: range[0..23]) = + self = orthoBases[idx] + +proc rotate*(self: var Vector3; axis: Vector3; phi: float32) = + self = initBasis(axis, phi).xform(self) + +proc rotated*(self: Vector3; axis: Vector3; phi: float32): Vector3 = + result = self + result.rotate(axis, phi) diff --git a/godot/core/color.nim b/godot/core/color.nim index f1b0d94..bb7f00b 100644 --- a/godot/core/color.nim +++ b/godot/core/color.nim @@ -3,74 +3,69 @@ import godotbase, strings type - Color* {.importc: "godot_color", header: "godot/color.h", byref.} = object + Color* {.byref.} = object + r: float32 + g: float32 + b: float32 + a: float32 -proc initColor(dest: var Color; r, g, b, a: float32) {. - importc: "godot_color_new_rgba", header: "godot/color.h".} -proc initColor(dest: var Color; r, g, b: float32) {. - importc: "godot_color_new_rgb", - header: "godot/color.h".} +proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} = + Color( + r: r, + g: g, + b: b, + a: a + ) -proc initColor*(r, g, b, a: float32): Color {.inline.} = - initColor(result, r, g, b, a) - -proc initColor*(r, g, b: float32): Color {.inline.} = - initColor(result, r, g, b) - -proc r*(self: Color): float32 {. - importc: "godot_color_get_r", header: "godot/color.h".} -proc `r=`*(self: var Color; r: float32) {. - importc: "godot_color_set_r", header: "godot/color.h".} -proc g*(self: Color): float32 {. - importc: "godot_color_get_g", header: "godot/color.h".} -proc `g=`*(self: var Color; g: float32) {. - importc: "godot_color_set_g", header: "godot/color.h".} -proc b*(self: Color): float32 {. - importc: "godot_color_get_b", header: "godot/color.h".} -proc `b=`*(self: var Color; b: float32) {. - importc: "godot_color_set_b", header: "godot/color.h".} -proc a*(self: Color): float32 {. - importc: "godot_color_get_a", header: "godot/color.h".} -proc `a=`*(self: var Color; a: float32) {. - importc: "godot_color_set_a", header: "godot/color.h".} +proc initColor*(): Color {.inline.} = + ## Initializes black color with 1.0 alpha + initColor(0, 0, 0) proc h*(self: Color): float32 {. - importc: "godot_color_get_h", header: "godot/color.h".} + importc: "godot_color_get_h".} proc s*(self: Color): float32 {. - importc: "godot_color_get_s", header: "godot/color.h".} + importc: "godot_color_get_s".} proc v*(self: Color): float32 {. - importc: "godot_color_get_v", header: "godot/color.h".} + importc: "godot_color_get_v".} -proc toGodotString*(self: Color): GodotString {. - importc: "godot_color_as_string", header: "godot/color.h".} proc `$`*(self: Color): string {.inline.} = - $self.toGodotString() + result = newStringOfCap(50) + result.add($self.r) + result.add(", ") + result.add($self.g) + result.add(", ") + result.add($self.b) + result.add(", ") + result.add($self.a) proc toHtml*(self: Color; with_alpha: bool): GodotString {. - importc: "godot_color_to_html", header: "godot/color.h".} + importc: "godot_color_to_html".} -proc to32CInt(self: Color): cint {. - importc: "godot_color_to_32", header: "godot/color.h".} -proc toARGB32CInt(self: Color): cint {. - importc: "godot_color_to_ARGB32", header: "godot/color.h".} - -proc to32*(self: Color): uint32 {.inline.}= - cast[uint32](to32CInt(self)) -proc toARGB32*(self: Color): uint32 {.inline.} = - cast[uint32](toARGB32CInt(self)) +proc toARGB32*(self: Color): uint32 = + result = uint8(self.a * 255) + result = (result shl 8) or uint8(self.r * 255) + result = (result shl 8) or uint8(self.g * 255) + result = (result shl 8) or uint8(self.b * 255) proc gray*(self: Color): float32 {. - importc: "godot_color_gray", header: "godot/color.h".} + importc: "godot_color_gray".} proc inverted*(self: Color): Color {. - importc: "godot_color_inverted", header: "godot/color.h".} + importc: "godot_color_inverted".} proc contrasted*(self: Color): Color {. - importc: "godot_color_contrasted", header: "godot/color.h".} + importc: "godot_color_contrasted".} proc lerp*(self: Color; b: Color; t: float32): Color {. - importc: "godot_color_linear_interpolate", header: "godot/color.h".} + importc: "godot_color_linear_interpolate".} proc blend*(self: Color; over: Color): Color {. - importc: "godot_color_blend", header: "godot/color.h".} + importc: "godot_color_blend".} -proc `==`*(self, b: Color): bool {. - importc: "godot_color_operator_equal", header: "godot/color.h".} -proc `<`*(self, b: Color): bool {. - importc: "godot_color_operator_less", header: "godot/color.h".} +proc `==`*(a, b: Color): bool = + a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a + +proc `<`*(a, b: Color): bool = + if a.r == b.r: + if a.g == b.g: + if a.b == b.b: + return a.a < b.a + return a.b < b.b + return a.g < b.g + return a.r < b.r diff --git a/godot/core/dictionary.nim b/godot/core/dictionary.nim index 5c937b6..e21f15a 100644 --- a/godot/core/dictionary.nim +++ b/godot/core/dictionary.nim @@ -4,26 +4,24 @@ import hashes import godotbase, arrays, variant, strings type - Dictionary* {.importc: "godot_dictionary", - header: "godot/dictionary.h", byref.} = object + Dictionary* {.byref.} = object + p: pointer proc initVariant(dest: var Variant; dict: Dictionary) {. - importc: "godot_variant_new_dictionary", - header: "godot/variant.h".} + importc: "godot_variant_new_dictionary".} proc variant*(dict: Dictionary): Variant {.inline.} = initVariant(result, dict) proc asDictionary*(self: Variant): Dictionary {. - importc: "godot_variant_as_dictionary", header: "godot/variant.h".} + importc: "godot_variant_as_dictionary".} proc initDictionary(dest: var Dictionary; src: Dictionary) {. - importc: "godot_dictionary_new_copy", - header: "godot/dictionary.h".} + importc: "godot_dictionary_new_copy".} proc deinit(self: var Dictionary) {. - importc: "godot_dictionary_destroy", header: "godot/dictionary.h".} + importc: "godot_dictionary_destroy".} proc `=`(self: var Dictionary, other: Dictionary) {.inline.} = initDictionary(self, other) @@ -32,54 +30,49 @@ proc `=destroy`(self: Dictionary) {.inline.} = unsafeAddr(self)[].deinit() proc initDictionary(dest: var Dictionary) {. - importc: "godot_dictionary_new", header: "godot/dictionary.h".} + importc: "godot_dictionary_new".} proc initDictionary*(): Dictionary {.inline.} = initDictionary(result) proc len*(self: Dictionary): cint {. - importc: "godot_dictionary_size", header: "godot/dictionary.h".} + importc: "godot_dictionary_size".} proc isEmpty*(self: Dictionary): bool {. - importc: "godot_dictionary_empty", header: "godot/dictionary.h".} + importc: "godot_dictionary_empty".} proc clear*(self: var Dictionary) {. - importc: "godot_dictionary_clear", header: "godot/dictionary.h".} + importc: "godot_dictionary_clear".} proc contains*(self: Dictionary; key: Variant): bool {. - importc: "godot_dictionary_has", - header: "godot/dictionary.h".} + importc: "godot_dictionary_has".} proc contains*(self: Dictionary; keys: Array): bool {. - importc: "godot_dictionary_has_all", - header: "godot/dictionary.h".} + importc: "godot_dictionary_has_all".} proc del*(self: var Dictionary; key: Variant) {. - importc: "godot_dictionary_erase", header: "godot/dictionary.h".} + importc: "godot_dictionary_erase".} proc godotHash*(self: Dictionary): cint {. - importc: "godot_dictionary_hash", header: "godot/dictionary.h".} + importc: "godot_dictionary_hash".} proc hash*(self: Dictionary): Hash {.inline.} = hash(godotHash(self)) proc keys*(self: Dictionary): Array {. - importc: "godot_dictionary_keys", header: "godot/dictionary.h".} + importc: "godot_dictionary_keys".} proc values*(self: Dictionary): Array {. - importc: "godot_dictionary_values", header: "godot/dictionary.h".} + importc: "godot_dictionary_values".} proc `[]`*(self: Dictionary; key: Variant): Variant {. - importc: "godot_dictionary_get", header: "godot/dictionary.h".} + importc: "godot_dictionary_get".} proc `[]`*(self: Dictionary; keyStr: string): Variant = let key = variant(keyStr) result = self[key] proc `[]=`*(self: var Dictionary; key, value: Variant) {. - importc: "godot_dictionary_set", - header: "godot/dictionary.h".} + importc: "godot_dictionary_set".} proc mget*(self: var Dictionary; key: Variant): ptr Variant {. - importc: "godot_dictionary_operator_index", - header: "godot/dictionary.h".} + importc: "godot_dictionary_operator_index".} proc `==`*(self, other: Dictionary): bool {. - importc: "godot_dictionary_operator_equal", - header: "godot/dictionary.h".} + importc: "godot_dictionary_operator_equal".} proc toJson*(self: Dictionary): GodotString {. - importc: "godot_dictionary_to_json", header: "godot/dictionary.h".} + importc: "godot_dictionary_to_json".} iterator keys*(dict: Dictionary): Variant = let keyArr = dict.keys() diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index 22fe3b6..3f469a0 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -1,8 +1,9 @@ # Copyright (c) 2017 Xored Software, Inc. +import math + type - Error* {.importc: "godot_error", header: "godot/gdnative.h", - size: sizeof(cint), pure.} = enum + Error* {.size: sizeof(cint), pure.} = enum OK, Failed, ## Generic fail error Unavailable, ## What is requested is unsupported/unavailable @@ -59,17 +60,16 @@ type const MAX_ARG_COUNT* = 128 type - GodotObject* {.importc: "godot_object", header: "godot/gdnative.h".} = object - Array* {.importc: "godot_array", header: "godot/array.h", byref.} = object - Variant* {.importc: "godot_variant", - header: "godot/variant.h", byref.} = object + GodotObject* = object + Array* {.byref.} = object + p: pointer + Variant* {.byref.} = object + data: array[24, byte] proc initArray(dest: var Array, src: Array) {. - importc: "godot_array_new_copy", - header: "godot/array.h".} + importc: "godot_array_new_copy".} -proc deinit(self: var Array) {.importc: "godot_array_destroy", - header: "godot/array.h".} +proc deinit(self: var Array) {.importc: "godot_array_destroy".} proc `=`(self: var Array, other: Array) {.inline.} = initArray(self, other) @@ -78,10 +78,10 @@ proc `=destroy`(self: Array) {.inline.} = unsafeAddr(self).deinit() proc initVariant(dest: var Variant; src: Variant) {. - importc: "godot_variant_new_copy", header: "godot/variant.h".} + importc: "godot_variant_new_copy".} proc deinit*(self: var Variant) {. - importc: "godot_variant_destroy", header: "godot/variant.h".} + importc: "godot_variant_destroy".} proc `=`(self: var Variant, other: Variant) {.inline.} = initVariant(self, other) @@ -92,16 +92,61 @@ proc `=destroy`(self: Variant) {.inline.} = # System Functions proc godotAlloc*(bytes: cint): pointer {. - importc: "godot_alloc", header: "godot/gdnative.h".} + importc: "godot_alloc".} ## Allocates the specified number of bytes. ## Using this instead of stdlib proc will help Godot track how much memory ## is in use in debug mode. proc godotRealloc*(p: pointer; bytes: cint): pointer {. - importc: "godot_realloc", header: "godot/gdnative.h".} + importc: "godot_realloc".} ## Reallocates the pointer for the specified number of bytes. ## Using this instead of stdlib proc will help Godot track how much memory ## is in use in debug mode. -proc godotFree*(p: pointer) {.importc: "godot_free", header: "godot/gdnative.h".} +proc godotFree*(p: pointer) {.importc: "godot_free".} ## Frees the memory pointed to by the pointer. ## Using this instead of stdlib proc will help Godot track how much memory ## is in use in debug mode. + +# print using Godot's error handler list + +proc godotPrintError(description: cstring; function: cstring; file: cstring; + line: cint) {. + importc: "godot_print_error".} + +proc godotPrintWarning(description: cstring; function: cstring; + file: cstring; line: cint) {. + importc: "godot_print_warning".} + +template printWarning*(warn: typed) = + let (filename, line) = instantiationInfo() + godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint) + +template printError*(err: typed) = + let (filename, line) = instantiationInfo() + godotPrintError(cstring($err), nil, cstring(filename), line.cint) + +# math helpers + +const EPSILON = 0.00001'f32 +proc isEqualApprox*(a, b: float32): bool {.inline.} = + abs(a - b) < EPSILON + +proc isEqualApprox*(a, b: float64): bool {.inline.} = + abs(a - b) < EPSILON + +proc sign*(a: float32): float32 {.inline.} = + if a < 0: -1.0'f32 else: 1.0'f32 + +proc sign*(a: float64): float64 {.inline.} = + if a < 0: -1.0'f64 else: 1.0'f64 + +proc stepify*(value, step: float64): float64 = + if step != 0'f64: + floor(value / step + 0.5'f64) * step + else: + value + +proc stepify*(value, step: float32): float32 = + if step != 0'f32: + floor(value / step + 0.5'f32) * step + else: + value diff --git a/godot/core/godotcore.nim b/godot/core/godotcore.nim index f0b51ff..00521d4 100644 --- a/godot/core/godotcore.nim +++ b/godot/core/godotcore.nim @@ -11,53 +11,44 @@ export godotbase, strings, vector2, rect2, vector3, transform2d, plane, quat, # MethodBind API -type - GodotMethodBind* {.importc: "godot_method_bind", - header: "godot/gdnative.h".} = object +type GodotMethodBind* = object proc getMethod*(className: cstring; methodName: cstring): ptr GodotMethodBind {. - importc: "godot_method_bind_get_method", header: "godot/gdnative.h".} + importc: "godot_method_bind_get_method".} proc ptrCall*(methodBind: ptr GodotMethodBind; instance: ptr GodotObject; args: ptr array[MAX_ARG_COUNT, pointer]; ret: pointer) {. - importc: "godot_method_bind_ptrcall", header: "godot/gdnative.h".} + importc: "godot_method_bind_ptrcall".} proc call*(methodBind: ptr GodotMethodBind; instance: ptr GodotObject; args: var ptr array[MAX_ARG_COUNT, Variant]; argCount: cint; callError: var VariantCallError): Variant {. - importc: "godot_method_bind_call", header: "godot/gdnative.h".} + importc: "godot_method_bind_call".} # Script API type - GodotNativeInitOptions* {.importc: "godot_gdnative_init_options", - header: "godot/gdnative.h".} = object - inEditor* {.importc: "in_editor".}: bool - coreApiHash* {.importc: "core_api_hash".}: uint64 - editorApiHash* {.importc: "editor_api_hash".}: uint64 - noApiHash* {.importc: "no_api_hash".}: uint64 + GodotNativeInitOptions* = object + inEditor*: bool + coreApiHash*: uint64 + editorApiHash*: uint64 + noApiHash*: uint64 - GodotNativeTerminateOptions* {.importc: "godot_gdnative_terminate_options", - header: "godot/gdnative.h".} = object - inEditor* {.importc: "in_editor".}: bool + GodotNativeTerminateOptions* = object + inEditor*: bool - GodotMethodRPCMode* {.importc: "godot_method_rpc_mode", - header: "godot_nativescript.h", - size: sizeof(cint), pure.} = enum + GodotMethodRPCMode* {.size: sizeof(cint), pure.} = enum Disabled, Remote, Sync, Master, Slave - GodotMethodAttributes* {.importc: "godot_method_attributes", - header: "godot_nativescript.h".} = object - rpcMode* {.importc: "rpc_type".}: GodotMethodRPCMode + GodotMethodAttributes* = object + rpcMode*: GodotMethodRPCMode - GodotPropertyHint* {.importc: "godot_property_hint", - header: "godot_nativescript.h", - size: sizeof(cint), pure.} = enum + GodotPropertyHint* {.size: sizeof(cint), pure.} = enum None, ## no hint provided. Range, ## hint_text = "min,max,step,slider; // slider is optional" ExpRange, ## hint_text = "min,max,step", exponential edit @@ -126,9 +117,7 @@ const GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE type - GodotPropertyUsageFlags* {.importc: "godot_property_usage_flags", - header: "godot_nativescript.h", size: sizeof(cint), - pure.} = enum + GodotPropertyUsageFlags* {.size: sizeof(cint), pure.} = enum Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE @@ -156,143 +145,98 @@ type AnimateAsTrigger = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE UpdateAllIfModified = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE - GodotPropertyAttributes* {.importc: "godot_property_attributes", - header: "godot_nativescript.h", bycopy.} = object - rsetType* {.importc: "rset_type".}: GodotMethodRPCMode - typ* {.importc: "type".}: cint - hint* {.importc: "hint".}: GodotPropertyHint - hintString* {.importc: "hint_string".}: GodotString - usage* {.importc: "usage".}: GodotPropertyUsageFlags - defaultValue* {.importc: "default_value".}: Variant + GodotPropertyAttributes* {.bycopy.} = object + rsetType*: GodotMethodRPCMode + typ*: cint + hint*: GodotPropertyHint + hintString*: GodotString + usage*: GodotPropertyUsageFlags + defaultValue*: Variant - GodotInstanceCreateFunc* {.importc: "godot_instance_create_func", - header: "godot_nativescript.h", bycopy.} = object - createFunc* {.importc: "create_func".}: + GodotInstanceCreateFunc* {.bycopy.} = object + createFunc*: proc (obj: ptr GodotObject; methodData: pointer): pointer {.noconv.} ## returns user data - methodData* {.importc: "method_data".}: pointer - freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.} + methodData*: pointer + freeFunc*: proc (a2: pointer) {.noconv.} - GodotInstanceDestroyFunc* {.importc: "godot_instance_destroy_func", - header: "godot_nativescript.h", bycopy.} = object - destroyFunc* {.importc: "destroy_func".}: + GodotInstanceDestroyFunc* {.bycopy.} = object + destroyFunc*: proc (obj: ptr GodotObject; methodData: pointer; userData: pointer) {.noconv.} - methodData* {.importc: "method_data".}: pointer - freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.} + methodData*: pointer + freeFunc*: proc (a2: pointer) {.noconv.} proc godotScriptRegisterClass*(libHandle: pointer; name, base: cstring; create_func: GodotInstanceCreateFunc; destroy_func: GodotInstanceDestroyFunc) {. - importc: "godot_nativescript_register_class", - header: "godot_nativescript.h".} + importc: "godot_nativescript_register_class".} proc godotScriptRegisterToolClass*(libHandle: pointer; name, base: cstring; createFunc: GodotInstanceCreateFunc; destroyFunc: GodotInstanceDestroyFunc) {. - importc: "godot_nativescript_register_tool_class", - header: "godot_nativescript.h".} + importc: "godot_nativescript_register_tool_class".} type - GodotInstanceMethod* {.importc: "godot_instance_method", - header: "godot_nativescript.h", bycopy.} = object - meth* {.importc: "method".}: + GodotInstanceMethod* {.bycopy.} = object + meth*: proc (obj: ptr GodotObject; methodData: pointer; userData: pointer; numArgs: cint; args: var ptr array[MAX_ARG_COUNT, Variant]): Variant {.noconv.} - methodData* {.importc: "method_data".}: pointer - freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.} + methodData*: pointer + freeFunc*: proc (a2: pointer) {.noconv.} proc godotScriptRegisterMethod*(libHandle: pointer; name: cstring; function_name: cstring; attr: GodotMethodAttributes; meth: GodotInstanceMethod) {. - importc: "godot_nativescript_register_method", - header: "godot_nativescript.h".} + importc: "godot_nativescript_register_method".} type - GodotPropertySetFunc* {.importc: "godot_property_set_func", - header: "godot_nativescript.h", bycopy.} = object - setFunc* {.importc: "set_func".}: proc (obj: ptr GodotObject; - methodData: pointer; - userData: pointer; - value: Variant) {.noconv.} - methodData* {.importc: "method_data".}: pointer - freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.} + GodotPropertySetFunc* {.bycopy.} = object + setFunc*: proc (obj: ptr GodotObject; methodData: pointer; + userData: pointer; value: Variant) {.noconv.} + methodData*: pointer + freeFunc*: proc (a2: pointer) {.noconv.} - GodotPropertyGetFunc* {.importc: "godot_property_get_func", - header: "godot_nativescript.h", bycopy.} = object - getFunc* {.importc: "get_func".}: - proc (obj: ptr GodotObject; methodData: pointer; - userData: pointer): Variant {.noconv.} - methodData* {.importc: "method_data".}: pointer - freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.} + GodotPropertyGetFunc* {.bycopy.} = object + getFunc*: proc (obj: ptr GodotObject; methodData: pointer; + userData: pointer): Variant {.noconv.} + methodData*: pointer + freeFunc*: proc (a2: pointer) {.noconv.} proc godotScriptRegisterProperty*(libHandle: pointer; name: cstring; path: cstring; attr: var GodotPropertyAttributes; setFunc: GodotPropertySetFunc; getFunc: GodotPropertyGetFunc) {. - importc: "godot_nativescript_register_property", - header: "godot_nativescript.h".} + importc: "godot_nativescript_register_property".} type - GodotSignalArgument* {.importc: "godot_signal_argument", - header: "godot_nativescript.h", bycopy.} = object - name* {.importc: "name".}: GodotString - typ* {.importc: "type".}: cint - hint* {.importc: "hint".}: GodotPropertyHint - hintString* {.importc: "hint_string".}: GodotString - usage* {.importc: "usage".}: GodotPropertyUsageFlags - defaultValue* {.importc: "default_value".}: Variant + GodotSignalArgument* {.bycopy.} = object + name*: GodotString + typ*: cint + hint*: GodotPropertyHint + hintString*: GodotString + usage*: GodotPropertyUsageFlags + defaultValue*: Variant - GodotSignal* {.importc: "godot_signal", - header: "godot_nativescript.h".} = object - name* {.importc: "name".}: GodotString - numArgs* {.importc: "num_args".}: cint - args* {.importc: "args".}: ptr GodotSignalArgument - numDefaultArgs* {.importc: "num_default_args".}: cint - defaultArgs* {.importc: "default_args".}: ptr Variant + GodotSignal* = object + name*: GodotString + numArgs*: cint + args*: ptr GodotSignalArgument + numDefaultArgs*: cint + defaultArgs*: ptr Variant proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring; signal: GodotSignal) {. - importc: "godot_nativescript_register_signal", - header: "godot_nativescript.h".} + importc: "godot_nativescript_register_signal".} proc getUserdata*(instance: ptr GodotObject): pointer {. - importc: "godot_nativescript_get_userdata", header: "godot_nativescript.h".} + importc: "godot_nativescript_get_userdata".} proc godotNew*(p_classname: cstring): ptr GodotObject {. - importc: "godot_nativescript_new", header: "godot_nativescript.h".} + importc: "godot_nativescript_new".} proc godotStackBottom*(): pointer {. - importc: "godot_get_stack_bottom", header: "godot/gdnative.h".} + importc: "godot_get_stack_bottom".} proc deinit*(o: ptr GodotObject) {. - importc: "godot_object_destroy", header: "godot/gdnative.h".} - -# print using Godot's error handler list - -proc godotPrintError(description: cstring; function: cstring; file: cstring; - line: cint) {. - importc: "godot_print_error", header: "godot/gdnative.h".} - -proc godotPrintWarning(description: cstring; function: cstring; - file: cstring; line: cint) {. - importc: "godot_print_warning", header: "godot/gdnative.h".} - -proc godotPrint(message: GodotString) {. - importc: "godot_print", header: "godot/gdnative.h".} - -proc print*(message: string) {.inline.} = - let s = message.toGodotString() - godotPrint(s) - -proc print*(message: cstring) {.inline.} = - let s = message.toGodotString() - godotPrint(s) - -template printWarning*(warn: typed) = - let (filename, line) = instantiationInfo() - godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint) - -template printError*(err: typed) = - let (filename, line) = instantiationInfo() - godotPrintError(cstring($err), nil, cstring(filename), line.cint) + importc: "godot_object_destroy".} diff --git a/godot/core/nodepath.nim b/godot/core/nodepath.nim index 1c2112f..2a2300b 100644 --- a/godot/core/nodepath.nim +++ b/godot/core/nodepath.nim @@ -3,16 +3,16 @@ import godotbase, strings type - NodePath* {.importc: "godot_node_path", - header: "godot/node_path.h", byref.} = object + NodePath* {.byref.} = object + p: pointer proc initNodePath(dest: var NodePath; s: GodotString) {. - importc: "godot_node_path_new", header: "godot/node_path.h".} + importc: "godot_node_path_new".} proc initNodePath(dest: var NodePath; src: NodePath) {. - importc: "godot_node_path_new_copy", header: "godot/node_path.h".} + importc: "godot_node_path_new_copy".} proc deinit(self: var NodePath) {. - importc: "godot_node_path_destroy", header: "godot/node_path.h".} + importc: "godot_node_path_destroy".} proc initNodePath*(s: string): NodePath {.inline.} = initNodePath(result, s.toGodotString()) @@ -24,32 +24,28 @@ proc `=`(self: var NodePath, other: NodePath) {.inline.} = initNodePath(self, other) proc toGodotString*(self: NodePath): GodotString {. - importc: "godot_node_path_as_string", header: "godot/node_path.h".} + importc: "godot_node_path_as_string".} proc `$`*(self: NodePath): string {.inline.} = let s = self.toGodotString() result = $s proc isAbsolute*(self: NodePath): bool {. - importc: "godot_node_path_is_absolute", header: "godot/node_path.h".} + importc: "godot_node_path_is_absolute".} proc nameCount*(self: NodePath): cint {. - importc: "godot_node_path_get_name_count", - header: "godot/node_path.h".} + importc: "godot_node_path_get_name_count".} proc getName*(self: NodePath; idx: cint): GodotString {. - importc: "godot_node_path_get_name", header: "godot/node_path.h".} + importc: "godot_node_path_get_name".} proc subnameCount*(self: NodePath): cint {. - importc: "godot_node_path_get_subname_count", - header: "godot/node_path.h".} + importc: "godot_node_path_get_subname_count".} proc getSubname*(self: NodePath; idx: cint): GodotString {. - importc: "godot_node_path_get_subname", - header: "godot/node_path.h".} + importc: "godot_node_path_get_subname".} proc property*(self: NodePath): GodotString {. - importc: "godot_node_path_get_property", header: "godot/node_path.h".} + importc: "godot_node_path_get_property".} proc isEmpty*(self: NodePath): bool {. - importc: "godot_node_path_is_empty", header: "godot/node_path.h".} + importc: "godot_node_path_is_empty".} proc `==`*(a, b: NodePath): bool {. - importc: "godot_node_path_operator_equal", - header: "godot/node_path.h".} + importc: "godot_node_path_operator_equal".} converter fromString*(s: string): NodePath = initNodePath(result, s.toGodotString()) diff --git a/godot/core/plane.nim b/godot/core/plane.nim index f2378cb..b425fea 100644 --- a/godot/core/plane.nim +++ b/godot/core/plane.nim @@ -3,16 +3,16 @@ import godotbase, vector3, strings type - Plane* {.importc: "godot_plane", header: "godot/plane.h", byref.} = object + Plane* {.byref.} = object + normal*: Vector3 + d*: float32 proc initPlane(dest: var Plane; a, b, c, d: float32) {. - importc: "godot_plane_new_with_reals", header: "godot/plane.h".} + importc: "godot_plane_new_with_reals".} proc initPlane(dest: var Plane; v1, v2, v3: Vector3) {. - importc: "godot_plane_new_with_vectors", - header: "godot/plane.h".} + importc: "godot_plane_new_with_vectors".} proc initPlane(dest: var Plane; normal: Vector3; d: float32) {. - importc: "godot_plane_new_with_normal", - header: "godot/plane.h".} + importc: "godot_plane_new_with_normal".} proc initPlane*(a, b, c, d: float32): Plane = initPlane(result, a, b, c, d) @@ -23,62 +23,48 @@ proc initPlane*(v1, v2, v3: Vector3): Plane = proc initPlane*(normal: Vector3; d: float32): Plane = initPlane(result, normal, d) -proc toGodotString*(self: Plane): GodotString {. +proc toGodotString(self: Plane): GodotString {. noSideEffect, - importc: "godot_plane_as_string", header: "godot/plane.h".} + importc: "godot_plane_as_string".} proc `$`*(self: Plane): string {.inline.} = $self.toGodotString() proc normalized*(self: Plane): Plane {. noSideEffect, - importc: "godot_plane_normalized", header: "godot/plane.h".} + importc: "godot_plane_normalized".} proc center*(self: Plane): Vector3 {. noSideEffect, - importc: "godot_plane_center", header: "godot/plane.h".} + importc: "godot_plane_center".} proc getAnyPoint*(self: Plane): Vector3 {. noSideEffect, - importc: "godot_plane_get_any_point", header: "godot/plane.h".} + importc: "godot_plane_get_any_point".} proc isPointOver*(self: Plane; point: Vector3): bool {. noSideEffect, - importc: "godot_plane_is_point_over", - header: "godot/plane.h".} + importc: "godot_plane_is_point_over".} proc distanceTo*(self: Plane; point: Vector3): float32 {. noSideEffect, - importc: "godot_plane_distance_to", header: "godot/plane.h".} + importc: "godot_plane_distance_to".} proc contains*(self: Plane; point: Vector3; epsilon: float32): bool {. noSideEffect, - importc: "godot_plane_has_point", header: "godot/plane.h".} + importc: "godot_plane_has_point".} proc project*(self: Plane; point: Vector3): Vector3 {. noSideEffect, - importc: "godot_plane_project", header: "godot/plane.h".} + importc: "godot_plane_project".} proc intersect3*(self: Plane; dest: var Vector3; b, c: Plane): bool {. noSideEffect, - importc: "godot_plane_intersect_3", - header: "godot/plane.h".} + importc: "godot_plane_intersect_3".} proc intersectsRay*(self: Plane; dest: var Vector3; v, dir: Vector3): bool {. noSideEffect, - importc: "godot_plane_intersects_ray", - header: "godot/plane.h".} + importc: "godot_plane_intersects_ray".} proc intersectsSegment*(self: Plane; dest: var Vector3; segmentBegin, segmentEnd: Vector3): bool {. - noSideEffect, importc: "godot_plane_intersects_segment", - header: "godot/plane.h".} + noSideEffect, importc: "godot_plane_intersects_segment".} proc `-`*(self: Plane): Plane {. noSideEffect, - importc: "godot_plane_operator_neg", header: "godot/plane.h".} + importc: "godot_plane_operator_neg".} proc `==`*(a, b: Plane): bool {. noSideEffect, - importc: "godot_plane_operator_equal", header: "godot/plane.h".} -proc normal*(self: Plane): Vector3 {. - noSideEffect, - importc: "godot_plane_get_normal", header: "godot/plane.h".} -proc `normal=`*(self: var Plane; normal: Vector3) {. - importc: "godot_plane_set_normal", header: "godot/plane.h".} -proc d*(self: Plane): float32 {. - noSideEffect, - importc: "godot_plane_get_d", header: "godot/plane.h".} -proc `d=`*(self: var Plane; d: float32) {. - importc: "godot_plane_set_d", header: "godot/plane.h".} \ No newline at end of file + importc: "godot_plane_operator_equal".} diff --git a/godot/core/poolarray.nim b/godot/core/poolarray.nim index da5bf2f..4fdf22c 100644 --- a/godot/core/poolarray.nim +++ b/godot/core/poolarray.nim @@ -3,35 +3,33 @@ import godotbase, color, vector2, vector3, strings type - PoolByteArray* {.importc: "godot_pool_byte_array", - header: "godot/pool_arrays.h", byref.} = object - PoolIntArray* {.importc: "godot_pool_int_array", - header: "godot/pool_arrays.h", byref.} = object - PoolRealArray* {.importc: "godot_pool_real_array", - header: "godot/pool_arrays.h", byref.} = object - PoolStringArray* {.importc: "godot_pool_string_array", - header: "godot/pool_arrays.h", byref.} = object - PoolVector2Array* {.importc: "godot_pool_vector2_array", - header: "godot/pool_arrays.h", byref.} = object - PoolVector3Array* {.importc: "godot_pool_vector3_array", - header: "godot/pool_arrays.h", byref.} = object - PoolColorArray* {.importc: "godot_pool_color_array", - header: "godot/pool_arrays.h", byref.} = object + PoolByteArray* {.byref.} = object + p: pointer + PoolIntArray* {.byref.} = object + p: pointer + PoolRealArray* {.byref.} = object + p: pointer + PoolStringArray* {.byref.} = object + p: pointer + PoolVector2Array* {.byref.} = object + p: pointer + PoolVector3Array* {.byref.} = object + p: pointer + PoolColorArray* {.byref.} = object + p: pointer # byte proc initPoolByteArray(dest: var PoolByteArray) {. - importc: "godot_pool_byte_array_new", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_new".} proc initPoolByteArray(dest: var PoolByteArray; src: PoolByteArray) {. - importc: "godot_pool_byte_array_new_copy", - header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_new_copy".} proc initPoolByteArray(dest: var PoolByteArray; arr: Array) {. - importc: "godot_pool_byte_array_new_with_array", - header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_new_with_array".} proc deinit(self: var PoolByteArray) {. - importc: "godot_pool_byte_array_destroy", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_destroy".} proc initPoolByteArray*(): PoolByteArray {.inline.} = initPoolByteArray(result) @@ -47,33 +45,31 @@ proc `=destroy`(self: PoolByteArray) {.inline.} = proc add*(self: var PoolByteArray; data: uint8) {. - importc: "godot_pool_byte_array_append", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_append".} proc addFirst*(self: var PoolByteArray, data: uint8) {. - importc: "godot_pool_byte_array_push_back", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_push_back".} proc add*(self: var PoolByteArray; arr: PoolByteArray) {. - importc: "godot_pool_byte_array_append_array", - header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_append_array".} proc insert*(self: var PoolByteArray; idx: cint; data: uint8): Error {. - importc: "godot_pool_byte_array_insert", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_insert".} proc delete*(self: var PoolByteArray; idx: cint) {. - importc: "godot_pool_byte_array_remove", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_remove".} proc reverse*(self: var PoolByteArray) {. - importc: "godot_pool_byte_array_invert", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_invert".} proc setLen*(self: var PoolByteArray; size: cint) {. - importc: "godot_pool_byte_array_resize", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_resize".} proc `[]=`*(self: var PoolByteArray; idx: cint; data: uint8) {. - importc: "godot_pool_byte_array_set", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_set".} proc `[]`*(self: PoolByteArray; idx: cint): uint8 {. noSideEffect, - importc: "godot_pool_byte_array_get", - header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_get".} proc len*(self: PoolByteArray): cint {. noSideEffect, - importc: "godot_pool_byte_array_size", header: "godot/pool_arrays.h".} + importc: "godot_pool_byte_array_size".} iterator items*(arr: PoolByteArray): byte = for i in 0.. Date: Fri, 28 Jul 2017 00:28:17 +0700 Subject: [PATCH 014/160] No destructors --- godot/apigen/apigen.nim | 75 +-- godot/core/arrays.nim | 216 +++++---- godot/core/basis.nim | 2 +- godot/core/{color.nim => colors.nim} | 31 +- godot/core/dictionaries.nim | 93 ++++ godot/core/dictionary.nim | 89 ---- godot/core/godotbase.nim | 114 ++--- godot/core/nodepath.nim | 51 --- godot/core/nodepaths.nim | 69 +++ godot/core/{plane.nim => planes.nim} | 5 +- godot/core/poolarray.nim | 430 ------------------ godot/core/poolarrays.nim | 126 +++++ godot/core/{quat.nim => quats.nim} | 31 +- godot/core/rect2.nim | 7 +- godot/core/rect3.nim | 8 +- godot/core/{rid.nim => rids.nim} | 2 + godot/core/transform2d.nim | 10 +- godot/core/{transform.nim => transforms.nim} | 7 +- godot/core/variant.nim | 269 ----------- godot/core/variants.nim | 251 ++++++++++ godot/core/vector2.nim | 7 +- godot/core/vector3.nim | 2 +- godot/godot.nim | 17 +- .../{core/godotcore.nim => godotinternal.nim} | 58 ++- godot/internal/godotarrays.nim | 115 +++++ godot/internal/godotdictionaries.nim | 48 ++ godot/internal/godotinternaltypes.nim | 8 + godot/internal/godotnodepaths.nim | 32 ++ godot/internal/godotpoolarrays.nim | 376 +++++++++++++++ .../strings.nim => internal/godotstrings.nim} | 20 - godot/internal/godotvariants.nim | 190 ++++++++ godot/nim/godotmacros.nim | 56 +-- godot/nim/godotnim.nim | 100 ++-- godot/nimruntime.nim | 2 +- 34 files changed, 1701 insertions(+), 1216 deletions(-) rename godot/core/{color.nim => colors.nim} (68%) create mode 100644 godot/core/dictionaries.nim delete mode 100644 godot/core/dictionary.nim delete mode 100644 godot/core/nodepath.nim create mode 100644 godot/core/nodepaths.nim rename godot/core/{plane.nim => planes.nim} (97%) delete mode 100644 godot/core/poolarray.nim create mode 100644 godot/core/poolarrays.nim rename godot/core/{quat.nim => quats.nim} (75%) rename godot/core/{rid.nim => rids.nim} (93%) rename godot/core/{transform.nim => transforms.nim} (94%) delete mode 100644 godot/core/variant.nim create mode 100644 godot/core/variants.nim rename godot/{core/godotcore.nim => godotinternal.nim} (84%) create mode 100644 godot/internal/godotarrays.nim create mode 100644 godot/internal/godotdictionaries.nim create mode 100644 godot/internal/godotinternaltypes.nim create mode 100644 godot/internal/godotnodepaths.nim create mode 100644 godot/internal/godotpoolarrays.nim rename godot/{core/strings.nim => internal/godotstrings.nim} (76%) create mode 100644 godot/internal/godotvariants.nim diff --git a/godot/apigen/apigen.nim b/godot/apigen/apigen.nim index 85f00a1..4b9ec5b 100644 --- a/godot/apigen/apigen.nim +++ b/godot/apigen/apigen.nim @@ -104,12 +104,6 @@ proc postfix(left: PNode, op: string): PNode = result.add(ident(op)) result.add(left) -proc newExprColonExpr(key, value: PNode): PNode = - newNode(nkExprColonExpr).addChain(key, value) - -proc pragma(key: PNode, value: PNode): PNode = - newNode(nkPragma).addChain(key, value) - proc newBracketExpr(first, bracket: PNode): PNode = newNode(nkBracketExpr).addChain(first, bracket) @@ -263,9 +257,9 @@ const standardTypes = toSet( "uint64", "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform", - "Color", "NodePath", "RID", "Dictionary", "Array", "PoolByteArray", - "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", - "PoolVector3Array", "PoolColorArray", "Variant"]) + "Color", "RID", "NodePath", "Dictionary", "Variant", "Array", + "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", + "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32", "cint", "int", "Error"]) @@ -277,6 +271,12 @@ const floatTypes = union(float64Types, float32Types) const arrayTypes = toSet(["Array", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) +const wrapperTypes = union(arrayTypes, + toSet(["NodePath", "Dictionary", "Variant"])) + +proc getInternalPtr(varName: PNode, typ: string): PNode = + assert(typ in wrapperTypes) + result = newDotExpr(varName, ident("godot" & typ)) proc newNilCheck(ident, toAssign: PNode): PNode = newIfStmt(newCall("isNil", ident), @@ -301,7 +301,7 @@ proc makeDefaultValue(arg: MethodArg): PNode = result = newFloatLit(parseFloat(arg.defaultVal.str)) elif arg.defaultVal.str == "Null": if arg.typ == "Variant": - result = newCall("variant") + result = newCall("newVariant") else: result = newNilLit() elif arg.typ == "Color": @@ -376,7 +376,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newNode(nkPtrTy).addChain( newNode(nkBracketExpr).addChain( ident("array"), ident("MAX_ARG_COUNT"), - if isVarargs: ident("Variant") else: ident("pointer")))) + if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) + else: ident("pointer")))) staticArgsLen = if varargsName.isNil: args.len else: args.len - 1 if not varargsName.isNil: @@ -407,7 +408,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx) let isStandardType = arg.typ in standardTypes - let convArg = if not varargsName.isNil: newCall("toGodot", argName) + let isWrappedType = arg.typ in wrapperTypes + let convArg = if not varargsName.isNil: + getInternalPtr(newCall("toGodot", argName), "Variant") + elif isWrappedType: getInternalPtr(argName, arg.typ) elif isStandardType: newCall("unsafeAddr", argName) elif arg.typ == "string": newCall("unsafeAddr", ident("argToPassToGodot" & $idx)) @@ -418,7 +422,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], [arg.typ, godotMethodName, typ.godotName]) if not isStandardType and varargsName.isNil: if arg.typ == "string": - argConversions.add(newNode(nkLetSection).addChain( + argConversions.add(newNode(nkVarSection).addChain( newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), newCall("toGodotString", argName)))) else: @@ -465,11 +469,6 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(newNode(nkLetSection).addChain(newIdentDefs( ident("self"), newNode(nkEmpty), varName ))) - if not varargsName.isNil: - body.add( - pragma(ident("push"), newExprColonExpr( - newBracketExpr(ident("warning"), ident("Destructor")), - ident("off")))) body.add(nilCheck) body.add(vars) body.add(argConversions) @@ -482,9 +481,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var isConversionRet: bool var isObjRet: bool var isStringRet: bool + var isWrapperRet: bool let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName) - if not returnType.isNil and varargsName.isNil: - var addrToAssign = newCall("addr", ident("ptrCallVal")) + if not returnType.isNil and not isVarargs: + var addrToAssign = newCall("addr", retValIdent) if returnType in smallIntTypes: isConversionRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( @@ -495,6 +495,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("float64"), ))) + elif returnType in wrapperTypes: + isWrapperRet = true + body.add(newNode(nkVarSection).addChain(newIdentDefs( + retValIdent, ident("Godot" & returnType), + ))) elif returnType in standardTypes: addrToAssign = newCall("addr", ident("result")) elif returnType == "string": @@ -520,9 +525,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ident(retName), newNode(nkPragma).addChain(ident("used"))), newNode(nkEmpty), theCall)) body.add(callStmt) - # if not returnType.isNil and not varargsName.isNil: - # body.add(newCall("fromGodot", ident("result"), ident(retName))) - # body.add(newCall("deinit", ident(retName))) + + if varargsName.isNil: + for idx, arg in args: + if arg.typ == "string": + body.add(newCall("deinit", ident("argToPassToGodot" & $idx))) + if args.len > 0 and not varargsName.isNil: body.add(freeCall) if not varargsName.isNil: @@ -536,7 +544,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if isVariantRet: let convErrDef = newNode(nkLetSection).addChain( newIdentDefs(ident("convErr"), newNode(nkEmpty), - newCall("fromGodot", ident("result"), retValIdent))) + newCall("fromGodot", ident("result"), newCall("newVariant", retValIdent)))) let convCheck = newIfStmt( newInfix(ident("convErr"), ident("!="), newDotExpr(ident("ConversionResult"), ident("OK"))), @@ -545,12 +553,16 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ) body.add(convErrDef) body.add(convCheck) - if not isVarargs and (isVariantRet or isStringRet): - # varargs use call with "let" so destructor is invoked + if isStringRet: body.add(newCall("deinit", retValIdent)) elif isConversionRet: - body.add(newNode(nkAsgn).addChain(ident("result"), - newCall(returnType, retValIdent))) + body.add(newNode(nkAsgn).addChain( + ident("result"), + newCall(returnType, retValIdent))) + elif isWrapperRet: + body.add(newNode(nkAsgn).addChain( + ident("result"), + newCall("new" & returnType, retValIdent))) elif isObjRet: body.add(newNode(nkAsgn).addChain(ident("result"), newCall(newBracketExpr(ident("asNimGodotObject"), @@ -558,11 +570,6 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], elif isStringRet: body.add(newNode(nkAsgn).addChain(ident("result"), newCall("$", retValIdent))) - if not varargsName.isNil: - body.add( - pragma(ident("push"), newExprColonExpr( - newBracketExpr(ident("warning"), ident("Destructor")), - ident("on")))) let procType = if isVirtual: nkMethodDef else: nkProcDef @@ -770,7 +777,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) = let importStmt = newNode(nkImportStmt) importStmt.add(ident("godot")) importStmt.add(ident("godottypes")) - importStmt.add(newDotExpr(ident("core"), ident("godotcore"))) + importStmt.add(ident("godotinternal")) tree.add(importStmt) let exportStmt = newNode(nkExportStmt) exportStmt.add(ident("godottypes")) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index fcc065b..7f07a86 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,135 +1,127 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright 2017 Xored Software, Inc. import hashes -import godotbase, poolarray, variant, strings +import "../internal/godotinternaltypes.nim", "../internal/godotarrays.nim" -proc initArray(dest: var Array) {. - importc: "godot_array_new".} -proc initArray(dest: var Array; pca: PoolColorArray) {. - importc: "godot_array_new_pool_coloarray".} -proc initArray(dest: var Array; pv3a: PoolVector3Array) {. - importc: "godot_array_new_pool_vector3_array".} -proc initArray(dest: var Array; pv2a: PoolVector2Array) {. - importc: "godot_array_new_pool_vector2_array".} -proc initArray(dest: var Array; psa: PoolStringArray) {. - importc: "godot_array_new_pool_string_array".} -proc initArray(dest: var Array; pra: PoolRealArray) {. - importc: "godot_array_new_pool_real_array".} -proc initArray(dest: var Array; pia: PoolIntArray) {. - importc: "godot_array_new_pool_int_array".} -proc initArray(dest: var Array; pba: PoolByteArray) {. - importc: "godot_array_new_pool_byte_array".} +import godotbase, poolarrays -proc initArray*(): Array {.inline.} = - initArray(result) +proc arrayFinalizer(arr: Array) = + arr.godotArray[].deinit() -proc initArray*(pca: PoolColorArray): Array {.inline.} = - initArray(result, pca) +proc newArray*(): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[]) -proc initArray*(pv3a: PoolVector3Array): Array {.inline.} = - initArray(result, pv3a) +proc newArray*(arr: GodotArray): Array {.inline.} = + new(result, arrayFinalizer) + result.godotArray[] = arr -proc initArray*(pv2a: PoolVector2Array): Array {.inline.} = - initArray(result, pv2a) +proc newArray*(pca: PoolColorArray): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], pca.godotPoolColorArray[]) -proc initArray*(psa: PoolStringArray): Array {.inline.} = - initArray(result, psa) +proc newArray*(pv3a: PoolVector3Array): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], pv3a.godotPoolVector3Array[]) -proc initArray*(pra: PoolRealArray): Array {.inline.} = - initArray(result, pra) +proc newArray*(pv2a: PoolVector2Array): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], pv2a.godotPoolVector2Array[]) -proc initArray*(pia: PoolIntArray): Array {.inline.} = - initArray(result, pia) +proc newArray*(psa: PoolStringArray): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], psa.godotPoolStringArray[]) -proc initArray*(pba: PoolByteArray): Array {.inline.} = - initArray(result, pba) +proc newArray*(pra: PoolRealArray): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], pra.godotPoolRealArray[]) -proc `[]=`*(self: var Array; idx: cint; - value: Variant) {. - noSideEffect, - importc: "godot_array_set".} -proc `[]`*(self: Array; idx: cint): Variant {. - noSideEffect, - importc: "godot_array_get".} -proc mget*(self: var Array; idx: cint): ptr Variant {. - importc: "godot_array_operator_index".} +proc newArray*(pia: PoolIntArray): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], pia.godotPoolIntArray[]) -proc add*(self: var Array; value: Variant) {. - noSideEffect, - importc: "godot_array_append".} -proc clear*(self: var Array) {.importc: "godot_array_clear".} -proc count*(self: Array; value: Variant): cint {. - noSideEffect, - importc: "godot_array_count".} -proc isEmpty*(self: Array): bool {. - noSideEffect, - importc: "godot_array_empty".} -proc erase*(self: var Array; value: Variant) {. - importc: "godot_array_erase".} -proc first*(self: Array): Variant {. - noSideEffect, - importc: "godot_array_front".} -proc last*(self: Array): Variant {. - noSideEffect, - importc: "godot_array_back".} -proc find*(self: Array; what: Variant; - f: cint): cint {. - noSideEffect, - importc: "godot_array_find".} -proc findLast*(self: Array; what: Variant): cint {. - noSideEffect, - importc: "godot_array_find_last".} -proc contains*(self: Array; value: Variant): bool {. - noSideEffect, - importc: "godot_array_has".} +proc newArray*(pba: PoolByteArray): Array {.inline.} = + new(result, arrayFinalizer) + initGodotArray(result.godotArray[], pba.godotPoolByteArray[]) + +import variants + +proc `[]=`*(self: var Array; idx: int; value: Variant) {.inline.} = + self.godotArray[][idx.cint] = value.godotVariant[] + +proc `[]`*(self: Array; idx: int): Variant {.inline.} = + newVariant(self.godotArray[][idx.cint]) + +proc add*(self: var Array; value: Variant) {.inline.} = + self.godotArray[].add(value.godotVariant[]) + +proc clear*(self: var Array) {.inline.} = + self.godotArray[].clear() + +proc count*(self: Array; value: Variant): int {.inline.} = + self.godotArray[].count(value.godotVariant[]).int + +proc isEmpty*(self: Array): bool {.inline.} = + self.godotArray[].isEmpty() + +proc erase*(self: var Array; value: Variant) {.inline.} = + self.godotArray[].erase(value.godotVariant[]) + +proc first*(self: Array): Variant {.inline.} = + newVariant(self.godotArray[].first()) + +proc last*(self: Array): Variant {.inline.} = + newVariant(self.godotArray[].last()) + +proc find*(self: Array; what: Variant; f: int): int {.inline.} = + self.godotArray[].find(what.godotVariant[], f.cint).int + +proc findLast*(self: Array; what: Variant): int {.inline.} = + self.godotArray[].findLast(what.godotVariant[]).int + +proc contains*(self: Array; value: Variant): bool {.inline.} = + self.godotArray[].contains(value.godotVariant[]) -proc godotHash*(self: Array): cint {. - noSideEffect, - importc: "godot_array_hash".} proc hash*(self: Array): Hash {.inline.} = - hash(godotHash(self)) + hash(self.godotArray[].godotHash()) -proc insert*(self: var Array; pos: cint; - value: Variant) {. - importc: "godot_array_insert".} -proc reverse*(self: var Array) {.importc: "godot_array_invert".} -proc popLast*(self: var Array): Variant {. - importc: "godot_array_pop_back".} -proc popFirst*(self: var Array): Variant {. - importc: "godot_array_pop_front".} -proc addLast*(self: var Array; value: Variant) {. - importc: "godot_array_push_back".} -proc addFirst*(self: var Array; value: Variant) {. - importc: "godot_array_push_front".} +proc insert*(self: var Array; pos: int; value: Variant) {.inline.} = + self.godotArray[].insert(pos.cint, value.godotVariant[]) -proc delete*(self: var Array; idx: cint) {. - importc: "godot_array_remove".} -proc setLen*(self: var Array; size: cint) {. - importc: "godot_array_resize".} -proc rfind*(self: Array; what: Variant; - f: cint): cint {. - noSideEffect, - importc: "godot_array_rfind".} -proc len*(self: Array): cint {. - noSideEffect, - importc: "godot_array_size".} -proc sort*(self: var Array) {.importc: "godot_array_sort".} -proc sortCustom*(self: var Array; obj: var GodotObject; - funcName: GodotString) {. - importc: "godot_array_sort_custom".} +proc reverse*(self: var Array) {.inline.} = + self.godotArray[].reverse() -iterator items*(arr: Array): Variant = +proc popLast*(self: var Array): Variant {.inline.} = + newVariant(self.godotArray[].popLast()) + +proc popFirst*(self: var Array): Variant {.inline.} = + newVariant(self.godotArray[].popFirst()) + +proc addLast*(self: var Array; value: Variant) {.inline.} = + self.godotArray[].addLast(value.godotVariant[]) + +proc addFirst*(self: var Array; value: Variant) {.inline.} = + self.godotArray[].addFirst(value.godotVariant[]) + +proc delete*(self: var Array; idx: int) {.inline.} = + self.godotArray[].delete(idx.cint) + +proc setLen*(self: var Array; size: int) {.inline.} = + self.godotArray[].setLen(size.cint) + +proc rfind*(self: Array; what: Variant; f: int): int {.inline.} = + self.godotArray[].rfind(what.godotVariant[], f.cint).int + +proc len*(self: Array): int {.inline.} = + self.godotArray[].len.int + +proc sort*(self: var Array) {.inline.} = + self.godotArray[].sort() + +iterator items*(arr: Array): Variant {.inline.} = for i in 0.. 2 and result[^2] == 'S' and result[^1] == 'W': + # There are physics type not known by ClassDB + result = result[0..result.len-3] diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim new file mode 100644 index 0000000..c74a9ff --- /dev/null +++ b/godot/internal/godotarrays.nim @@ -0,0 +1,115 @@ +# Copyright (c) 2017 Xored Software, Inc. + +import hashes +import godotinternaltypes, godotpoolarrays, godotvariants, godotstrings + +proc initGodotArray*(dest: var GodotArray) {. + importc: "godot_array_new".} +proc initGodotArray*(dest: var GodotArray; pca: GodotPoolColorArray) {. + importc: "godot_array_new_pool_coloarray".} +proc initGodotArray*(dest: var GodotArray; pv3a: GodotPoolVector3Array) {. + importc: "godot_array_new_pool_vector3_array".} +proc initGodotArray*(dest: var GodotArray; pv2a: GodotPoolVector2Array) {. + importc: "godot_array_new_pool_vector2_array".} +proc initGodotArray*(dest: var GodotArray; psa: GodotPoolStringArray) {. + importc: "godot_array_new_pool_string_array".} +proc initGodotArray*(dest: var GodotArray; pra: GodotPoolRealArray) {. + importc: "godot_array_new_pool_real_array".} +proc initGodotArray*(dest: var GodotArray; pia: GodotPoolIntArray) {. + importc: "godot_array_new_pool_int_array".} +proc initGodotArray*(dest: var GodotArray; pba: GodotPoolByteArray) {. + importc: "godot_array_new_pool_byte_array".} +proc iniGodotArray*(dest: var GodotArray; src: GodotArray) {. + importc: "godot_array_new_copy".} + +proc deinit*(self: var GodotArray) {.importc: "godot_array_destroy".} + +proc `[]=`*(self: var GodotArray; idx: cint; + value: GodotVariant) {. + noSideEffect, + importc: "godot_array_set".} +proc `[]`*(self: GodotArray; idx: cint): GodotVariant {. + noSideEffect, + importc: "godot_array_get".} +proc mget*(self: var GodotArray; idx: cint): ptr GodotVariant {. + importc: "godot_array_operator_index".} + +proc add*(self: var GodotArray; value: GodotVariant) {. + noSideEffect, + importc: "godot_array_append".} +proc clear*(self: var GodotArray) {.importc: "godot_array_clear".} +proc count*(self: GodotArray; value: GodotVariant): cint {. + noSideEffect, + importc: "godot_array_count".} +proc isEmpty*(self: GodotArray): bool {. + noSideEffect, + importc: "godot_array_empty".} +proc erase*(self: var GodotArray; value: GodotVariant) {. + importc: "godot_array_erase".} +proc first*(self: GodotArray): GodotVariant {. + noSideEffect, + importc: "godot_array_front".} +proc last*(self: GodotArray): GodotVariant {. + noSideEffect, + importc: "godot_array_back".} +proc find*(self: GodotArray; what: GodotVariant; + f: cint): cint {. + noSideEffect, + importc: "godot_array_find".} +proc findLast*(self: GodotArray; what: GodotVariant): cint {. + noSideEffect, + importc: "godot_array_find_last".} +proc contains*(self: GodotArray; value: GodotVariant): bool {. + noSideEffect, + importc: "godot_array_has".} + +proc godotHash*(self: GodotArray): cint {. + noSideEffect, + importc: "godot_array_hash".} +proc hash*(self: GodotArray): Hash {.inline.} = + hash(godotHash(self)) + +proc insert*(self: var GodotArray; pos: cint; + value: GodotVariant) {. + importc: "godot_array_insert".} +proc reverse*(self: var GodotArray) {.importc: "godot_array_invert".} +proc popLast*(self: var GodotArray): GodotVariant {. + importc: "godot_array_pop_back".} +proc popFirst*(self: var GodotArray): GodotVariant {. + importc: "godot_array_pop_front".} +proc addLast*(self: var GodotArray; value: GodotVariant) {. + importc: "godot_array_push_back".} +proc addFirst*(self: var GodotArray; value: GodotVariant) {. + importc: "godot_array_push_front".} + +proc delete*(self: var GodotArray; idx: cint) {. + importc: "godot_array_remove".} +proc setLen*(self: var GodotArray; size: cint) {. + importc: "godot_array_resize".} +proc rfind*(self: GodotArray; what: GodotVariant; + f: cint): cint {. + noSideEffect, + importc: "godot_array_rfind".} +proc len*(self: GodotArray): cint {. + noSideEffect, + importc: "godot_array_size".} +proc sort*(self: var GodotArray) {.importc: "godot_array_sort".} +proc sortCustom*(self: var GodotArray; obj: var GodotObject; + funcName: GodotString) {. + importc: "godot_array_sort_custom".} + +iterator items*(arr: GodotArray): GodotVariant = + for i in 0.. Date: Fri, 28 Jul 2017 18:09:55 +0700 Subject: [PATCH 015/160] Add Impl postfix to procs duplicating methods --- godot/apigen/apigen.nim | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/godot/apigen/apigen.nim b/godot/apigen/apigen.nim index 4b9ec5b..295fd58 100644 --- a/godot/apigen/apigen.nim +++ b/godot/apigen/apigen.nim @@ -604,7 +604,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string], name: PNode, godotMethodName: string, typ: GodotType, args: seq[MethodArg], - returnType: string, isVirtual, isBase, withImplementation: bool) = + returnType: string, + isVirtual, isBase, withImplementation: bool) = doGenerateMethod( tree, methodBindRegistry, name, godotMethodName, typ, args, returnType, isVirtual, isBase, withImplementation) @@ -666,8 +667,14 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, args.add(("variantArgs", "Variant", JsonNode(nil), true)) let godotName = methodObj["name"].str + var nimName = toNimStyle(godotName) + if not godotName.startsWith('_'): + for meth in typ.jsonNode["methods"]: + if meth["name"].str == '_' & godotName: + nimName = nimName & "Impl" + generateMethod(tree, methodBindRegistry, - ident(toNimStyle(godotName)), methodObj["name"].str, + ident(nimName), methodObj["name"].str, typ, args, returnType, methodObj["is_virtual"].bval, isBase, withImplementation) From 7d91c2b5cb17f664df7a20941d62d8a615eeb5b3 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 18:26:36 +0700 Subject: [PATCH 016/160] Fix ambiguous calls when creating Variant from ints --- godot/core/variants.nim | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/godot/core/variants.nim b/godot/core/variants.nim index d8f372a..c967370 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -36,13 +36,23 @@ proc newVariant*(b: bool): Variant {.inline.} = new(result, variantFinalizer) initGodotVariant(result.godotVariant[], b) -proc newVariant*(i: uint64): Variant {.inline.} = - new(result, variantFinalizer) - initGodotVariant(result.godotVariant[], i) +# resolves Nim call ambiguities well +template numConstructor(T, ConvT) = + proc newVariant*(i: T): Variant {.inline.} = + new(result, variantFinalizer) + initGodotVariant(result.godotVariant[], ConvT(i)) -proc newVariant*(i: int64): Variant {.inline.} = - new(result, variantFinalizer) - initGodotVariant(result.godotVariant[], i) +numConstructor(uint8, uint64) +numConstructor(uint16, uint64) +numConstructor(uint32, uint64) +numConstructor(uint64, uint64) +numConstructor(uint, uint64) + +numConstructor(int8, int64) +numConstructor(int16, int64) +numConstructor(int32, int64) +numConstructor(int64, int64) +numConstructor(int, int64) proc newVariant*(r: cdouble): Variant {.inline.} = new(result, variantFinalizer) From 05c858ee4495c9057a91b1fec4387bb57c113fa4 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 18:44:01 +0700 Subject: [PATCH 017/160] Fix invokeVarArgs --- godot/godotinternal.nim | 3 ++- godot/nim/godotmacros.nim | 8 ++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index f19e7e4..8b9bb6b 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -180,7 +180,7 @@ type meth*: proc (obj: ptr GodotObject; methodData: pointer; userData: pointer; numArgs: cint; - args: var ptr array[MAX_ARG_COUNT, GodotVariant]): + args: var array[MAX_ARG_COUNT, ptr GodotVariant]): GodotVariant {.noconv.} methodData*: pointer freeFunc*: proc (a2: pointer) {.noconv.} @@ -263,6 +263,7 @@ proc getClassName*(o: ptr GodotObject): string = var ret: GodotString getClassMethodBind.ptrCall(o, nil, addr ret) result = $ret + deinit(ret) if result.len > 2 and result[^2] == 'S' and result[^1] == 'W': # There are physics type not known by ClassDB result = result[0..result.len-3] diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 10bfb62..fd151df 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -193,8 +193,8 @@ macro invokeVarArgs(procIdent, objIdent; ## error(...) template conv(procLit, argT, argSeq, idx, argIdent, errIdent) = - let v = newVariant(argSeq[idx]) - v.markNoDeinit() # args should be destroyed externally + let v = newVariant(argSeq[idx][]) + v.markNoDeinit() # args will be destroyed externally let (argIdent, errIdent) = godotToNim[argT](v) if errIdent != ConversionResult.OK: let errorKind = if errIdent == ConversionResult.TypeError: "a type error" @@ -202,7 +202,7 @@ macro invokeVarArgs(procIdent, objIdent; printError( "Failed to invoke Nim procedure " & $procLit & ": " & errorKind & " has occurred when converting argument " & $idx & - " of Godot type " & $argSeq[idx].getType()) + " of Godot type " & $argSeq[idx][].getType()) return # these help to avoid exporting internal modules @@ -439,7 +439,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = argTypes, methFuncIdent, hasReturnValue) = proc methFuncIdent(obj: ptr GodotObject, methodData: pointer, userData: pointer, numArgs: cint, - args: var ptr array[MAX_ARG_COUNT, GodotVariant]): + args: var array[MAX_ARG_COUNT, ptr GodotVariant]): GodotVariant {.noconv.} = let self = cast[classNameIdent](userData) when defined(release): From 712be9ca5a564fb7009010ec2dc0d3dede55b1f4 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 18:59:54 +0700 Subject: [PATCH 018/160] Add clean task to sample project --- examples/simple/nakefile.nim | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/examples/simple/nakefile.nim b/examples/simple/nakefile.nim index 0efcef7..8b4c033 100644 --- a/examples/simple/nakefile.nim +++ b/examples/simple/nakefile.nim @@ -34,3 +34,10 @@ task "build", "Builds the client for the current platform": genGodotApi() withDir "src": direShell("nimble", "make") + +task "clean", "Remove files produced by build": + removeDir("nimcache") + removeDir("src"/"nimcache") + removeDir("godotapi") + removeDir("project"/"_dlls") + removeFile("nakefile") From 5884cb766ae3cef50494ba3a1072903dce0f161e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 22:38:47 +0700 Subject: [PATCH 019/160] Fix invokeVarArgs return value --- godot/nim/godotmacros.nim | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index fd151df..727f89d 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -230,8 +230,7 @@ macro invokeVarArgs(procIdent, objIdent; invocation.add(argIdent) if hasReturnValue: let theCall = newNimNode(nnkBracketExpr).add(newNimNode(nnkDotExpr).add( - newCall("toGodot", newCall("newVariant", invocation)), - ident("godotVariant"))) + newCall("toGodot", invocation), ident("godotVariant"))) branchBody.add(getAst(initGodotVariantCall(ident("result"), theCall))) else: branchBody.add(invocation) From 04c97656d829530ee302eb9d701c8a149f0366d6 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 23:11:59 +0700 Subject: [PATCH 020/160] gdnew via creating NativeScript --- godot/godotinternal.nim | 8 +++--- godot/nim/godotnim.nim | 59 ++++++++++++++++++++++++++++++++++++----- 2 files changed, 58 insertions(+), 9 deletions(-) diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index 8b9bb6b..f2652ec 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -34,6 +34,7 @@ type coreApiHash*: uint64 editorApiHash*: uint64 noApiHash*: uint64 + gdNativeLibrary*: ptr GodotObject GodotNativeTerminateOptions* = object inEditor*: bool @@ -234,8 +235,9 @@ proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring; proc getUserdata*(instance: ptr GodotObject): pointer {. importc: "godot_nativescript_get_userdata".} -proc godotNew*(p_classname: cstring): ptr GodotObject {. - importc: "godot_nativescript_new".} +type ClassConstructor = proc (): ptr GodotObject {.noconv.} +proc getClassConstructor*(className: cstring): ClassConstructor {. + importc: "godot_get_class_constructor".} proc godotStackBottom*(): pointer {. importc: "godot_get_stack_bottom".} @@ -256,7 +258,7 @@ proc godotPrintWarning*(description: cstring; function: cstring; proc godotPrint*(message: GodotString) {. importc: "godot_print".} -var getClassMethodBind {.threadvar.}: ptr GodotMethodBind +var getClassMethodBind: ptr GodotMethodBind proc getClassName*(o: ptr GodotObject): string = if getClassMethodBind.isNil: getClassMethodBind = getMethod(cstring"Object", cstring"get_class") diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index a850f1e..7c6aa7e 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -68,6 +68,9 @@ proc print*(message: cstring) {.inline.} = s.deinit() var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo] +var classRegistryStatic {.compileTime.}: TableRef[cstring, ObjectInfo] +static: + classRegistryStatic = newTable[cstring, ObjectInfo]() static: import sets, strutils @@ -148,12 +151,20 @@ template registerClass*(T: typedesc; godotClassName: cstring, const base = baseNativeType(T) const isRef: bool = isReference(T) - classRegistry[godotClassName] = ObjectInfo( + let objInfo = ObjectInfo( constructor: constructor, baseNativeClass: base, isNative: isNativeParam, isRef: isRef ) + classRegistry[godotClassName] = objInfo + static: + let objInfoStatic = ObjectInfo( + baseNativeClass: base, + isNative: isNativeParam, + isRef: isRef + ) + classRegistryStatic[godotClassName] = objInfoStatic when isRef: static: refClasses.add(T.name) @@ -237,12 +248,48 @@ proc getSingleton*[T: NimGodotObject](): T = else: result = asNimGodotObject[T](singleton) +var gdNativeLibraryObj: ptr GodotObject + +var setClassNameMethod: ptr GodotMethodBind +var setLibraryMethod: ptr GodotMethodBind +var newMethod: ptr GodotMethodBind +type + PtrCallArgType = ptr array[MAX_ARG_COUNT, pointer] +proc newOwnObj[T: NimGodotObject](name: cstring): T = + let newNativeScript = getClassConstructor(cstring"NativeScript")() + if setClassNameMethod.isNil: + setClassNameMethod = + getMethod(cstring"NativeScript", cstring"set_class_name") + if setLibraryMethod.isNil: + setLibraryMethod = + getMethod(cstring"NativeScript", cstring"set_library") + if newMethod.isNil: + newMethod = getMethod(cstring"NativeScript", cstring"new") + var godotStrName = name.toGodotString() + var argPtr: pointer = addr godotStrName + setClassNameMethod.ptrCall( + newNativeScript, cast[PtrCallArgType](addr argPtr), nil) + deinit(godotStrName) + setLibraryMethod.ptrCall( + newNativeScript, cast[PtrCallArgType](addr gdNativeLibraryObj), nil) + + var err: VariantCallError + var ret = newMethod.call(newNativeScript, nil, 0, err) + if err.error != VariantCallErrorType.OK: + printError("Failed to invoke 'new' on NativeScript for " & $name) + elif ret.getType() != VariantType.Object: + printError("Expected that NativeScript::new returns Object, " & + "but it returned: " & $ret.getType()) + else: + result = asNimGodotObject[T](ret.asGodotObject()) + ret.deinit() + proc gdnew*[T: NimGodotObject](): T = const godotName = toGodotName(T) - let obj = godotNew(godotName) - if obj.isNil: - printError("godot_new returned nil for type " & $godotName) - result = asNimGodotObject[T](obj) + const objInfo = classRegistryStatic[godotName] + result = when objInfo.isNative: + asNimGodotObject[T](getClassConstructor(godotName)()) + else: newOwnObj[T](godotName) proc newCallError*(err: VariantCallError): ref CallError = let msg = case err.error: @@ -583,7 +630,7 @@ proc godot_nativescript_init(handle: pointer) {. proc godot_gdnative_init(options: ptr GodotNativeInitOptions) {. cdecl, exportc, dynlib.} = - discard + gdNativeLibraryObj = options.gdNativeLibrary proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. cdecl, exportc, dynlib.} = From 0fe948c4a1cde1111a405a78d08e569a483f8b99 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 23:18:43 +0700 Subject: [PATCH 021/160] Update README with sample project link --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 40ee649..90a3e1b 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,8 @@ Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here). +Documentation is coming. You can learn from the [sample project](examples/simple) in the meantime. + ## Links - [Godot Engine](http://www.godotengine.org/) @@ -9,6 +11,6 @@ Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/d ## License -This project is licensed under the MIT license. Read [LICENSE](https://github.com/pragmagic/godot-nim/blob/master/LICENSE) file for details. +This project is licensed under the MIT license. Read [LICENSE](LICENSE) file for details. Copyright (c) 2017 Xored Software, Inc. \ No newline at end of file From f30df6d81bc16b5007e3bc72e97302d9da756d56 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 28 Jul 2017 23:41:48 +0700 Subject: [PATCH 022/160] Remove redundant imports from the sample --- examples/simple/src/fpscounter.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/simple/src/fpscounter.nim b/examples/simple/src/fpscounter.nim index 2227513..01be84f 100644 --- a/examples/simple/src/fpscounter.nim +++ b/examples/simple/src/fpscounter.nim @@ -2,7 +2,7 @@ import strutils import godot -import engine, label, resource_loader, packed_scene +import engine, label gdobj FPSCounter of Label: var lastFPS: float32 From 360be5759e4f568ef8e3d9886c2dd095c7de5298 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 29 Jul 2017 21:50:11 +0700 Subject: [PATCH 023/160] Define Variant and Array in their own modules --- godot/core/arrays.nim | 79 +++++++++-------- godot/core/colors.nim | 2 - godot/core/dictionaries.nim | 3 +- godot/core/godotbase.nim | 28 ------ godot/core/nodepaths.nim | 2 - godot/core/planes.nim | 2 +- godot/core/poolarrays.nim | 72 +++++++++++++--- godot/core/quats.nim | 2 +- godot/core/rect2.nim | 2 +- godot/core/rect3.nim | 2 +- godot/core/rids.nim | 2 - godot/core/transform2d.nim | 2 +- godot/core/transforms.nim | 2 +- godot/core/variants.nim | 165 +++++++++++++++++++----------------- godot/core/vector2.nim | 2 - 15 files changed, 201 insertions(+), 166 deletions(-) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 7f07a86..f4fd7e1 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -3,120 +3,129 @@ import hashes import "../internal/godotinternaltypes.nim", "../internal/godotarrays.nim" -import godotbase, poolarrays +type + Array* = ref object + godotArray: GodotArray + +proc godotArray*(arr: Array): ptr GodotArray {.inline.} = + ## WARNING: do not keep the returned value for longer than the lifetime of + ## ``arr`` + addr arr.godotArray proc arrayFinalizer(arr: Array) = - arr.godotArray[].deinit() + arr.godotArray.deinit() proc newArray*(): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[]) + initGodotArray(result.godotArray) proc newArray*(arr: GodotArray): Array {.inline.} = new(result, arrayFinalizer) - result.godotArray[] = arr + result.godotArray = arr + +import poolarrays, variants proc newArray*(pca: PoolColorArray): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], pca.godotPoolColorArray[]) + initGodotArray(result.godotArray, pca.godotPoolColorArray[]) proc newArray*(pv3a: PoolVector3Array): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], pv3a.godotPoolVector3Array[]) + initGodotArray(result.godotArray, pv3a.godotPoolVector3Array[]) proc newArray*(pv2a: PoolVector2Array): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], pv2a.godotPoolVector2Array[]) + initGodotArray(result.godotArray, pv2a.godotPoolVector2Array[]) proc newArray*(psa: PoolStringArray): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], psa.godotPoolStringArray[]) + initGodotArray(result.godotArray, psa.godotPoolStringArray[]) proc newArray*(pra: PoolRealArray): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], pra.godotPoolRealArray[]) + initGodotArray(result.godotArray, pra.godotPoolRealArray[]) proc newArray*(pia: PoolIntArray): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], pia.godotPoolIntArray[]) + initGodotArray(result.godotArray, pia.godotPoolIntArray[]) proc newArray*(pba: PoolByteArray): Array {.inline.} = new(result, arrayFinalizer) - initGodotArray(result.godotArray[], pba.godotPoolByteArray[]) + initGodotArray(result.godotArray, pba.godotPoolByteArray[]) import variants proc `[]=`*(self: var Array; idx: int; value: Variant) {.inline.} = - self.godotArray[][idx.cint] = value.godotVariant[] + self.godotArray[idx.cint] = value.godotVariant[] proc `[]`*(self: Array; idx: int): Variant {.inline.} = - newVariant(self.godotArray[][idx.cint]) + newVariant(self.godotArray[idx.cint]) proc add*(self: var Array; value: Variant) {.inline.} = - self.godotArray[].add(value.godotVariant[]) + self.godotArray.add(value.godotVariant[]) proc clear*(self: var Array) {.inline.} = - self.godotArray[].clear() + self.godotArray.clear() proc count*(self: Array; value: Variant): int {.inline.} = - self.godotArray[].count(value.godotVariant[]).int + self.godotArray.count(value.godotVariant[]).int proc isEmpty*(self: Array): bool {.inline.} = - self.godotArray[].isEmpty() + self.godotArray.isEmpty() proc erase*(self: var Array; value: Variant) {.inline.} = - self.godotArray[].erase(value.godotVariant[]) + self.godotArray.erase(value.godotVariant[]) proc first*(self: Array): Variant {.inline.} = - newVariant(self.godotArray[].first()) + newVariant(self.godotArray.first()) proc last*(self: Array): Variant {.inline.} = - newVariant(self.godotArray[].last()) + newVariant(self.godotArray.last()) proc find*(self: Array; what: Variant; f: int): int {.inline.} = - self.godotArray[].find(what.godotVariant[], f.cint).int + self.godotArray.find(what.godotVariant[], f.cint).int proc findLast*(self: Array; what: Variant): int {.inline.} = - self.godotArray[].findLast(what.godotVariant[]).int + self.godotArray.findLast(what.godotVariant[]).int proc contains*(self: Array; value: Variant): bool {.inline.} = - self.godotArray[].contains(value.godotVariant[]) + self.godotArray.contains(value.godotVariant[]) proc hash*(self: Array): Hash {.inline.} = - hash(self.godotArray[].godotHash()) + hash(self.godotArray.godotHash()) proc insert*(self: var Array; pos: int; value: Variant) {.inline.} = - self.godotArray[].insert(pos.cint, value.godotVariant[]) + self.godotArray.insert(pos.cint, value.godotVariant[]) proc reverse*(self: var Array) {.inline.} = - self.godotArray[].reverse() + self.godotArray.reverse() proc popLast*(self: var Array): Variant {.inline.} = - newVariant(self.godotArray[].popLast()) + newVariant(self.godotArray.popLast()) proc popFirst*(self: var Array): Variant {.inline.} = - newVariant(self.godotArray[].popFirst()) + newVariant(self.godotArray.popFirst()) proc addLast*(self: var Array; value: Variant) {.inline.} = - self.godotArray[].addLast(value.godotVariant[]) + self.godotArray.addLast(value.godotVariant[]) proc addFirst*(self: var Array; value: Variant) {.inline.} = - self.godotArray[].addFirst(value.godotVariant[]) + self.godotArray.addFirst(value.godotVariant[]) proc delete*(self: var Array; idx: int) {.inline.} = - self.godotArray[].delete(idx.cint) + self.godotArray.delete(idx.cint) proc setLen*(self: var Array; size: int) {.inline.} = - self.godotArray[].setLen(size.cint) + self.godotArray.setLen(size.cint) proc rfind*(self: Array; what: Variant; f: int): int {.inline.} = - self.godotArray[].rfind(what.godotVariant[], f.cint).int + self.godotArray.rfind(what.godotVariant[], f.cint).int proc len*(self: Array): int {.inline.} = - self.godotArray[].len.int + self.godotArray.len.int proc sort*(self: var Array) {.inline.} = - self.godotArray[].sort() + self.godotArray.sort() iterator items*(arr: Array): Variant {.inline.} = for i in 0.. Date: Sat, 29 Jul 2017 22:00:21 +0700 Subject: [PATCH 024/160] Move alloc procs to godotinternal module --- godot/core/godotbase.nim | 17 ----------------- godot/godotinternal.nim | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index f2fcd53..0fda0cd 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -83,20 +83,3 @@ proc stepify*(value, step: float32): float32 = floor(value / step + 0.5'f32) * step else: value - -# System Functions - -proc godotAlloc*(bytes: cint): pointer {. - importc: "godot_alloc".} - ## Allocates the specified number of bytes. - ## Using this instead of stdlib proc will help Godot track how much memory - ## is in use in debug mode. -proc godotRealloc*(p: pointer; bytes: cint): pointer {. - importc: "godot_realloc".} - ## Reallocates the pointer for the specified number of bytes. - ## Using this instead of stdlib proc will help Godot track how much memory - ## is in use in debug mode. -proc godotFree*(p: pointer) {.importc: "godot_free".} - ## Frees the memory pointed to by the pointer. - ## Using this instead of stdlib proc will help Godot track how much memory - ## is in use in debug mode. diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index f2652ec..0ec3959 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -269,3 +269,20 @@ proc getClassName*(o: ptr GodotObject): string = if result.len > 2 and result[^2] == 'S' and result[^1] == 'W': # There are physics type not known by ClassDB result = result[0..result.len-3] + +# System Functions + +proc godotAlloc*(bytes: cint): pointer {. + importc: "godot_alloc".} + ## Allocates the specified number of bytes. + ## Using this instead of stdlib proc will help Godot track how much memory + ## is in use in debug mode. +proc godotRealloc*(p: pointer; bytes: cint): pointer {. + importc: "godot_realloc".} + ## Reallocates the pointer for the specified number of bytes. + ## Using this instead of stdlib proc will help Godot track how much memory + ## is in use in debug mode. +proc godotFree*(p: pointer) {.importc: "godot_free".} + ## Frees the memory pointed to by the pointer. + ## Using this instead of stdlib proc will help Godot track how much memory + ## is in use in debug mode. From 7185682025e1cf50d38e398ee50e4b5b3736c4e9 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 13:52:16 +0700 Subject: [PATCH 025/160] Dont import with '..' --- godot/core/arrays.nim | 2 +- godot/core/dictionaries.nim | 4 ++-- godot/core/nodepaths.nim | 2 +- godot/core/planes.nim | 2 +- godot/core/poolarrays.nim | 2 +- godot/core/quats.nim | 2 +- godot/core/rect2.nim | 2 +- godot/core/rect3.nim | 2 +- godot/core/rids.nim | 2 +- godot/core/transform2d.nim | 2 +- godot/core/transforms.nim | 2 +- godot/core/variants.nim | 8 ++++---- godot/core/vector2.nim | 2 +- godot/godot.nim.cfg | 1 + godot/internal/godotpoolarrays.nim | 4 ++-- godot/internal/godotvariants.nim | 10 +++++----- godot/nim/godotmacros.nim | 4 ++-- godot/nim/godotnim.nim | 14 +++++++------- 18 files changed, 34 insertions(+), 33 deletions(-) create mode 100644 godot/godot.nim.cfg diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index f4fd7e1..a32690d 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,7 +1,7 @@ # Copyright 2017 Xored Software, Inc. import hashes -import "../internal/godotinternaltypes.nim", "../internal/godotarrays.nim" +import internal.godotinternaltypes, internal.godotarrays type Array* = ref object diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index a8567f8..3c7c4c8 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,8 +1,8 @@ # Copyright 2017 Xored Software, Inc. import hashes -import "../internal/godotinternaltypes.nim", "../internal/godotstrings.nim", - "../internal/godotdictionaries.nim", "../internal/godotvariants.nim" +import internal.godotinternaltypes, internal.godotstrings, + internal.godotdictionaries, internal.godotvariants type Dictionary* = ref object diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index f46ebe1..3bdd41d 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -1,6 +1,6 @@ # Copyright 2017 Xored Software, Inc. -import "../internal/godotnodepaths.nim", "../internal/godotstrings.nim" +import internal.godotnodepaths, internal.godotstrings type NodePath* = ref object diff --git a/godot/core/planes.nim b/godot/core/planes.nim index 62c4d50..4c6ead5 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -2,7 +2,7 @@ import vector3 -import "../internal/godotstrings.nim" +import internal.godotstrings type Plane* {.byref.} = object diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 97a2c96..262612b 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -1,7 +1,7 @@ # Copyright 2017 Xored Software, Inc. import vector2, vector3, colors -import "../internal/godotpoolarrays.nim", "../internal/godotstrings.nim" +import internal.godotpoolarrays, internal.godotstrings type PoolByteArray* = ref object diff --git a/godot/core/quats.nim b/godot/core/quats.nim index f5da1c2..9e12d55 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -1,7 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. import vector3 -import "../internal/godotstrings.nim" +import internal.godotstrings type Quat* {.byref.} = object diff --git a/godot/core/rect2.nim b/godot/core/rect2.nim index d8d31fb..d2192b1 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -2,7 +2,7 @@ import vector2 -import "../internal/godotstrings.nim" +import internal.godotstrings type Rect2* {.byref.} = object diff --git a/godot/core/rect3.nim b/godot/core/rect3.nim index a8dba64..c695ce9 100644 --- a/godot/core/rect3.nim +++ b/godot/core/rect3.nim @@ -2,7 +2,7 @@ import planes, vector3 -import "../internal/godotstrings.nim" +import internal.godotstrings type Rect3* {.byref.} = object diff --git a/godot/core/rids.nim b/godot/core/rids.nim index 89ab96a..b63875c 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -1,4 +1,4 @@ -import "../internal/godotinternaltypes.nim" +import internal.godotinternaltypes type RID* {.byref.} = object diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index 08013f8..fece240 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -2,7 +2,7 @@ import vector2, rect2 -import "../internal/godotstrings.nim" +import internal.godotstrings type Transform2D* {.byref.} = object diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index aa587a1..6505948 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -2,7 +2,7 @@ import basis, vector3, planes, rect3 -import "../internal/godotstrings.nim" +import internal.godotstrings type Transform* {.byref.} = object diff --git a/godot/core/variants.nim b/godot/core/variants.nim index b1ed7bc..de63132 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -1,9 +1,9 @@ import tables -import "../internal/godotinternaltypes.nim" -import "../internal/godotvariants.nim" -import "../internal/godotpoolarrays.nim", "../internal/godotstrings.nim", - "../internal/godotnodepaths.nim" +import internal.godotinternaltypes +import internal.godotvariants +import internal.godotpoolarrays, internal.godotstrings, + internal.godotnodepaths type Variant* = ref object diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 1aa641a..8b9f6da 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -1,6 +1,6 @@ # Copyright (c) 2017 Xored Software, Inc. -import "../internal/godotstrings.nim" +import internal.godotstrings type Vector2* {.byref.} = object diff --git a/godot/godot.nim.cfg b/godot/godot.nim.cfg new file mode 100644 index 0000000..9e05300 --- /dev/null +++ b/godot/godot.nim.cfg @@ -0,0 +1 @@ +--path:"$projectdir" \ No newline at end of file diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index da7ca4c..50f8656 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -2,8 +2,8 @@ import godotinternaltypes, godotstrings -import "../core/godotbase.nim", "../core/colors.nim", - "../core/vector2.nim", "../core/vector3.nim" +import core.godotbase, core.colors, + core.vector2, core.vector3 type GodotPoolByteArray* {.byref.} = object diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 5aeb024..13c0f59 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -48,11 +48,11 @@ type import godotinternaltypes, godotpoolarrays, godotstrings, godotnodepaths, godotdictionaries -import "../core/vector2.nim", "../core/rect2.nim", - "../core/vector3.nim", "../core/transform2d.nim", "../core/planes.nim", - "../core/quats.nim", "../core/rect3.nim", "../core/basis.nim", - "../core/transforms.nim", "../core/colors.nim", "../core/rids.nim", - "../core/rect2.nim" +import core.vector2, core.rect2, + core.vector3, core.transform2d, core.planes, + core.quats, core.rect3, core.basis, + core.transforms, core.colors, core.rids, + core.rect2 proc getType*(p: GodotVariant): VariantType {. importc: "godot_variant_get_type".} diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 727f89d..42019e0 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -1,8 +1,8 @@ # Copyright 2017 Xored Software, Inc. import macros, tables, typetraits -import "../godotinternal.nim", "../internal/godotvariants.nim" -import godotnim, "../core/variants.nim" +import "../godotinternal.nim", internal.godotvariants +import godotnim, core.variants type VarDecl = ref object diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 7c6aa7e..450571b 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,13 +1,13 @@ # Copyright 2017 Xored Software, Inc. import tables, typetraits, macros -import "../core/godotbase.nim" -import "../core/vector2.nim", "../core/rect2.nim", - "../core/vector3.nim", "../core/transform2d.nim", - "../core/planes.nim", "../core/quats.nim", "../core/rect3.nim", - "../core/basis.nim", "../core/transforms.nim", "../core/colors.nim", - "../core/nodepaths.nim", "../core/rids.nim", "../core/dictionaries.nim", - "../core/arrays.nim", "../core/poolarrays.nim", "../core/variants.nim" +import core.godotbase +import core.vector2, core.rect2, + core.vector3, core.transform2d, + core.planes, core.quats, core.rect3, + core.basis, core.transforms, core.colors, + core.nodepaths, core.rids, core.dictionaries, + core.arrays, core.poolarrays, core.variants import "../godotinternal.nim" ## Definition of NimGodotObject and converters for built-in types. From 3b8b12833a066f2f3f15f492ddfc01fd16d5f906 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 15:55:52 +0700 Subject: [PATCH 026/160] Rename apigen/apigen.nim to godotapigen.nim --- .gitignore | 6 +- .vscode/settings.json | 2 +- examples/simple/nakefile.nim | 2 +- godot/apigen/apigen.nim | 876 +--------------------------------- godot/apigen/usage.txt | 3 - godot/godotapigen.nim | 877 +++++++++++++++++++++++++++++++++++ 6 files changed, 886 insertions(+), 880 deletions(-) delete mode 100644 godot/apigen/usage.txt create mode 100644 godot/godotapigen.nim diff --git a/.gitignore b/.gitignore index 7ed1b30..e45da94 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,8 @@ nimcache/ -.DS_Store + /godot/apigen/apigen /godot/apigen/apigen.exe +/godot/godotapigen +/godot/godotapigen.exe + +.DS_Store \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index c26d7e1..aa6f1c7 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -6,7 +6,7 @@ "files.eol": "\n", "files.trimTrailingWhitespace": true, "nim.project": ["godot/godot.nim", - "godot/apigen/apigen.nim"], + "godot/godotapigen.nim"], "nim.buildOnSave": false, "nim.lintOnSave": true, "nim.licenseString": "# Copyright 2017 Xored Software, Inc.\n\n", diff --git a/examples/simple/nakefile.nim b/examples/simple/nakefile.nim index 8b4c033..2d3075c 100644 --- a/examples/simple/nakefile.nim +++ b/examples/simple/nakefile.nim @@ -2,7 +2,7 @@ import nake import os, ospaths, times -import apigen.apigen +import godotapigen proc cmdParams(): string = let params = commandLineParams() diff --git a/godot/apigen/apigen.nim b/godot/apigen/apigen.nim index 295fd58..48c2348 100644 --- a/godot/apigen/apigen.nim +++ b/godot/apigen/apigen.nim @@ -1,875 +1,3 @@ -# Copyright 2017 Xored Software, Inc. +{.warning: "'apigen.apigen' module is deprecated and will be removed in v0.4.0. Use 'godotapigen' instead.".} -import streams, json, ospaths, strutils, times, sets, tables -import sequtils, algorithm -import compiler / [ast, renderer, idents, astalgo] - -proc ident(ident: string): PNode = - result = newNode(nkIdent) - result.ident = getIdent(ident) - -proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} = - for other in others: - node.add(other) - result = node - -proc newIdentDefs(name, typ: PNode, - defaultVal: PNode = nil): PNode = - result = newNode(nkIdentDefs) - result.add(name) - result.add(typ) - if defaultVal.isNil: - result.add(newNode(nkEmpty)) - else: - result.add(defaultVal) - -proc newProc(name: PNode, params: openArray[PNode], body = newNode(nkEmpty), - procType = nkProcDef): PNode = - result = newNode(procType) - result.add(name) - result.add(newNode(nkEmpty)) - result.add(newNode(nkEmpty)) - let formalParams = newNode(nkFormalParams) - for param in params: - formalParams.add(param) - result.add(formalParams) - result.add(newNode(nkEmpty)) - result.add(newNode(nkEmpty)) - result.add(body) - -proc newIfStmt(condition, body: PNode): PNode = - result = newNode(nkIfStmt) - let branch = newNode(nkElifBranch) - result.add(branch) - branch.add(condition) - branch.add(body) - -proc newCall(theProc: PNode, args: varargs[PNode]): PNode = - result = newNode(nkCall) - result.add(theProc) - for arg in args: - result.add(arg) - -proc newCall(theProc: string, args: varargs[PNode]): PNode = - newCall(ident(theProc), args) - -proc newStrLit(s: string): PNode = - result = newNode(nkStrLit) - result.strVal = s - -proc newRStrLit(s: string): PNode = - result = newNode(nkRStrLit) - result.strVal = s - -proc newCStringLit(s: string): PNode = - newNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s)) - -proc newIntLit(val: BiggestInt): PNode = - result = newNode(nkIntLit) - result.intVal = val - -proc newInt64Lit(val: BiggestInt): PNode = - result = newNode(nkInt64Lit) - result.intVal = val - -proc newFloatLit(val: BiggestFloat): PNode = - result = newNode(nkFloatLit) - result.floatVal = val - -proc newFloat64Lit(val: BiggestFloat): PNode = - result = newNode(nkFloat64Lit) - result.floatVal = val - -proc newNilLit(): PNode = - result = newNode(nkNilLit) - -proc newDotExpr(left, right: PNode): PNode = - result = newNode(nkDotExpr) - result.add(left) - result.add(right) - -proc newCommand(left, right: PNode): PNode = - result = newNode(nkCommand) - result.add(left) - result.add(right) - -proc newInfix(left, op, right: PNode): PNode = - result = newNode(nkInfix) - result.add(op) - result.add(left) - result.add(right) - -proc postfix(left: PNode, op: string): PNode = - result = newNode(nkPostfix) - result.add(ident(op)) - result.add(left) - -proc newBracketExpr(first, bracket: PNode): PNode = - newNode(nkBracketExpr).addChain(first, bracket) - -proc newEmptyNode(): PNode = - newNode(nkEmpty) - -type GodotType = ref object - name: string - godotName: string - baseName: string - doc: string - derivedCount: int - isSingleton: bool - jsonNode: JsonNode - -proc findCommonRoot(typeRegistry: Table[string, GodotType], - types: seq[string]): string = - if types.len == 0: return "Object" - var chains = newSeq[seq[string]](types.len) - for idx, typ in types: - chains[idx] = newSeq[string]() - chains[idx].add(typ) - var curTyp = typeRegistry[typ] - while curTyp.baseName != "NimGodotObject": - chains[idx].add(curTyp.baseName) - curTyp = typeRegistry[curTyp.baseName] - chains[idx].reverse() - - var idx = 0 - while true: - var curType: string - var allEqual = true - for chain in chains: - if idx >= chain.len: - allEqual = false - break - if curType.isNil: - curType = chain[idx] - elif curType != chain[idx]: - allEqual = false - break - if allEqual: - result = curType - else: - break - inc idx - -proc incDerivedCount(types: var Table[string, GodotType], - className: string) = - let typ = types.getOrDefault(className) - if not typ.isNil: - inc typ.derivedCount - types.incDerivedCount(typ.baseName) - -proc toNimType(godotType: string): string = - case godotType: - of "float": "float64" - of "int": "int64" - of "String": "string" - of "File": "godottypes.File" - else: godotType - -proc toNimType(types: Table[string, GodotType], godotType: string): string = - let origType = - if godotType.contains(','): - findCommonRoot(types, godotType.split(',')) - else: - godotType - result = toNimType(origType) - -proc toNimStyle(name: string): string = - result = newStringOfCap(name.len + 1) - var i = 0 - var makeUpperCase: bool - while i < name.len: - if name[i] == '_': - if result.len != 0: - makeUpperCase = true - elif name[i] != '/': # remove slashes - if makeUpperCase: - result.add(name[i].toUpperAscii()) - makeUpperCase = false - else: - result.add(name[i]) - inc i - - while isKeyword(getIdent(result)): - result.add(result[result.len - 1]) - - if result == "result": - result = "resultVal" - -proc newRefTypeNode(typeSection: PNode, typ, base, doc: string, - isExported = true) = - let typeDef = newNode(nkTypeDef) - typeSection.add(typeDef) - if isExported: - typeDef.add(postfix(ident(typ), "*")) - else: - typeDef.add(ident(typ)) - - typeDef.add(newNode(nkEmpty)) # generic - let objTy = newNode(nkObjectTy) - let refTy = newNode(nkRefTy) - refTy.add(objTy) - typeDef.add(refTy) - - objTy.add(newNode(nkEmpty)) - let inherit = newNode(nkOfInherit) - inherit.add(ident(base)) - objTy.add(inherit) - - if not doc.isNil: - let recList = newNode(nkRecList) - let docNode = newNode(nkCommentStmt) - docNode.comment = doc - recList.add(docNode) - objTy.add(recList) - else: - objTy.add(newNode(nkEmpty)) - -proc makeConstSection(constObj: JsonNode): PNode = - if constObj.len == 0: - return newNode(nkEmpty) - - result = newNode(nkConstSection) - for field, val in constObj: - let def = newNode(nkConstDef) - def.add(postfix(ident(field), "*")) - def.add(newNode(nkEmpty)) # infer type - var valNode: PNode - if val.kind == JInt: - valNode = newInt64Lit(val.num) - # valNode.intVal = val.num - elif val.kind == JFloat: - valNode = newFloat64Lit(val.fnum) - elif val.kind == JBool: - valNode = ident($val.bval) - elif val.kind == JString: - valNode = newNode(nkStrLit) - valNode.strVal = val.str - else: - raise newException(ValueError, "Unexpected constant kind: " & $val.kind) - def.add(valNode) - result.add(def) - -type MethodArg = tuple[name, typ: string, defaultVal: JsonNode, isVarargs: bool] - -const standardTypes = toSet( - ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", - "uint64", - "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", - "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform", - "Color", "RID", "NodePath", "Dictionary", "Variant", "Array", - "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", - "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) - -const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32", - "cint", "int", "Error"]) -const int64Types = toSet(["uint64", "int64"]) -const intTypes = union(smallIntTypes, int64Types) -const float64Types = toSet(["float64", "cdouble"]) -const float32Types = toSet(["float32", "cfloat"]) -const floatTypes = union(float64Types, float32Types) -const arrayTypes = toSet(["Array", "PoolByteArray", - "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", - "PoolVector3Array", "PoolColorArray"]) -const wrapperTypes = union(arrayTypes, - toSet(["NodePath", "Dictionary", "Variant"])) - -proc getInternalPtr(varName: PNode, typ: string): PNode = - assert(typ in wrapperTypes) - result = newDotExpr(varName, ident("godot" & typ)) - -proc newNilCheck(ident, toAssign: PNode): PNode = - newIfStmt(newCall("isNil", ident), - newNode(nkAsgn).addChain(ident).addChain( - toAssign - ) - ) - -proc singletonName(typ: string): PNode = - ident("singleton" & typ) - -proc makeDefaultValue(arg: MethodArg): PNode = - result = newEmptyNode() - if not arg.defaultVal.isNil: - if arg.typ == "bool": - result = ident(arg.defaultVal.str.toLowerAscii()) - elif arg.typ in intTypes: - result = newInt64Lit(parseBiggestInt(arg.defaultVal.str)) - elif arg.typ == "string" or arg.typ == "NodePath": - result = newStrLit(arg.defaultVal.str) - elif arg.typ in floatTypes: - result = newFloatLit(parseFloat(arg.defaultVal.str)) - elif arg.defaultVal.str == "Null": - if arg.typ == "Variant": - result = newCall("newVariant") - else: - result = newNilLit() - elif arg.typ == "Color": - result = newCall("initColor", - arg.defaultVal.str.split(',').mapIt(newFloatLit(parseFloat(it)))) - # elif arg.typ in arrayTypes and (arg.defaultVal.str == "[]" or - # arg.defaultVal.str == "[" & arg.typ & "]"): - # result = newCall("init" & arg.typ) - elif arg.typ == "RID" and arg.defaultVal.str == "[RID]": - result = newCall("initRID") - elif arg.typ == "Vector2" or arg.typ == "Vector3" or arg.typ == "Rect2": - let parts = arg.defaultVal.str.replace("(", "").replace(")", ""). - replace(" ", ""). - split(",").mapIt(newFloatLit(parseFloat(it))) - if arg.typ.endsWith("r2"): - result = newCall("vec2", parts) - elif arg.typ.endsWith('3'): - result = newCall("vec3", parts) - else: - result = newCall("initRect2", parts) - elif arg.defaultVal.str == "[Object:null]": - result = newNilLit() - elif arg.typ != "Transform" and arg.typ != "Transform2D" and - arg.typ != "Variant" and arg.typ notin arrayTypes: # TODO - raise newException( - ValueError, - "Cannot build default value from $# ($#)" % - [$arg.defaultVal, arg.typ]) - -proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], - name: PNode, godotMethodName: string, - typ: GodotType, args: seq[MethodArg], - returnType: string, isVirtual, - isBase, withImplementation: bool) = - var body: PNode - if not withImplementation: - body = newNode(nkEmpty) - else: - var methodBindName = toNimStyle( - typ.name & "_" & godotMethodName & "_method_bind") - if methodBindName[0].isUpperAscii(): - methodBindName[0] = methodBindName[0].toLowerAscii() - if methodBindName notin methodBindRegistry: - let methodBindDecl = newNode(nkVarSection).addChain( - newIdentDefs( - newNode(nkPragmaExpr).addChain( - ident(methodBindName)).addChain( - newNode(nkPragma).addChain(ident("threadvar"))), - newNode(nkPtrTy).addChain(ident("GodotMethodBind")) - )) - tree.add(methodBindDecl) - methodBindRegistry.incl(methodBindName) - - let nilCheck = newNilCheck(ident(methodBindName), - newCall("getMethod", newCStringLit(typ.godotName), - newCStringLit(godotMethodName)) - ) - let vars = newNode(nkVarSection) - var varargsName: string - var isVarargs: bool - var staticArgsLen: int - var argLenNode = newIntLit(0) - let argsName = ident("argsToPassToGodot") - if args.len > 0: - for arg in args: - if arg.isVarargs: - varargsName = arg.name - isVarargs = true - vars.add(newIdentDefs(ident("callError"), ident("VariantCallError"))) - break - let argsAlloc = newNode(nkCast).addChain( - newNode(nkPtrTy).addChain( - newNode(nkBracketExpr).addChain( - ident("array"), ident("MAX_ARG_COUNT"), - if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) - else: ident("pointer")))) - staticArgsLen = if varargsName.isNil: args.len - else: args.len - 1 - if not varargsName.isNil: - argLenNode = newCall("cint", - newInfix(newIntLit(staticArgsLen), - ident("+"), - newDotExpr(ident(varargsName), ident("len")))) - argsAlloc.add(newCall("godotAlloc", newCall("cint", newInfix( - newCall("sizeof", ident("Variant")), ident("*"), - newNode(nkPar).addChain(argLenNode)))) - ) - else: - argLenNode = newCall("cint", newIntLit(staticArgsLen)) - vars.add(newIdentDefs( - ident("argsStatic"), - newNode(nkBracketExpr).addChain( - ident("array"), newIntLit(staticArgsLen), ident("pointer")), - newNode(nkEmpty))) - argsAlloc.add(newCommand(ident("addr"), ident("argsStatic"))) - vars.add(newIdentDefs(argsName, newNode(nkEmpty), argsAlloc)) - - let argConversions = newNode(nkStmtList) - for idx, arg in args: - var argName = ident(arg.name) - if arg.isVarargs: - argName = newNode(nkBracketExpr).addChain( - ident(varargsName), - newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) - let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx) - let isStandardType = arg.typ in standardTypes - let isWrappedType = arg.typ in wrapperTypes - let convArg = if not varargsName.isNil: - getInternalPtr(newCall("toGodot", argName), "Variant") - elif isWrappedType: getInternalPtr(argName, arg.typ) - elif isStandardType: newCall("unsafeAddr", argName) - elif arg.typ == "string": newCall("unsafeAddr", - ident("argToPassToGodot" & $idx)) - else: ident("argToPassToGodot" & $idx) # object - if not isStandardType and arg.isVarargs: - raise newException(ValueError, - "Non-standard type $# for varargs params of method $# of type $#" % - [arg.typ, godotMethodName, typ.godotName]) - if not isStandardType and varargsName.isNil: - if arg.typ == "string": - argConversions.add(newNode(nkVarSection).addChain( - newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), - newCall("toGodotString", argName)))) - else: - argConversions.add(newNode(nkLetSection).addChain( - newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), - newDotExpr(argName, ident("godotObject"))))) - let argAsgn = newNode(nkAsgn).addChain( - newNode(nkBracketExpr).addChain( - newNode(nkBracketExpr).addChain(argsName), argIdx), - convArg - ) - if not arg.isVarargs: - argConversions.add( - argAsgn - ) - else: - argConversions.add(newNode(nkVarSection).addChain( - newIdentDefs(ident("idx"), newNode(nkEmpty), newIntLit(staticArgsLen)))) - let argLoop = newNode(nkWhileStmt) - argConversions.add(argLoop) - argLoop.add(newInfix(ident("idx"), ident("<"), argLenNode) - ) - argLoop.add(newNode(nkStmtList).addChain( - argAsgn, - newCommand(ident("inc"), ident("idx")))) - - let retName = if isVarargs: "callRet" else: "ptrCallRet" - let theCall = newCall( - newDotExpr(ident(methodBindName), - ident(if isVarargs: "call" else: "ptrCall")), - newDotExpr(ident("self"), ident("godotObject")), - if args.len > 0: argsName else: newNode(nkNilLit), - argLenNode, - if not isVarargs: ident(retName) else: ident("callError") - ) - if not isVarargs: - theCall.sons.delete(3) - let freeCall = newCall("godotFree", argsName) - body = newNode(nkStmtList) - if typ.isSingleton: - let varName = singletonName(typ.name) - body.add(newNilCheck(varName, newCall( - newBracketExpr(ident("getSingleton"), ident(typ.name))))) - body.add(newNode(nkLetSection).addChain(newIdentDefs( - ident("self"), newNode(nkEmpty), varName - ))) - body.add(nilCheck) - body.add(vars) - body.add(argConversions) - if not isVarargs: - let retPtrDecl = newNode(nkVarSection).addChain( - newIdentDefs(ident(retName), ident("pointer"), newEmptyNode()) - ) - body.add(retPtrDecl) - var isVariantRet: bool - var isConversionRet: bool - var isObjRet: bool - var isStringRet: bool - var isWrapperRet: bool - let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName) - if not returnType.isNil and not isVarargs: - var addrToAssign = newCall("addr", retValIdent) - if returnType in smallIntTypes: - isConversionRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, ident("int64"), - ))) - elif returnType in float32Types: - isConversionRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, ident("float64"), - ))) - elif returnType in wrapperTypes: - isWrapperRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, ident("Godot" & returnType), - ))) - elif returnType in standardTypes: - addrToAssign = newCall("addr", ident("result")) - elif returnType == "string": - isStringRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, ident("GodotString"), - ))) - else: - isObjRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")), - ))) - body.add(newNode(nkAsgn).addChain(ident(retName), addrToAssign)) - - if not isVarargs: - body.add(theCall) - else: - if not returnType.isNil: - isVariantRet = true - let callStmt = newNode(nkLetSection).addChain( - newIdentDefs( - newNode(nkPragmaExpr).addChain( - ident(retName), newNode(nkPragma).addChain(ident("used"))), - newNode(nkEmpty), theCall)) - body.add(callStmt) - - if varargsName.isNil: - for idx, arg in args: - if arg.typ == "string": - body.add(newCall("deinit", ident("argToPassToGodot" & $idx))) - - if args.len > 0 and not varargsName.isNil: - body.add(freeCall) - if not varargsName.isNil: - let errCheck = newIfStmt( - newInfix(newDotExpr(ident("callError"), ident("error")), ident("!="), - newDotExpr(ident("VariantCallErrorType"), ident("OK"))), - newNode(nkRaiseStmt).addChain( - newCall("newCallError", ident("callError"))) - ) - body.add(errCheck) - if isVariantRet: - let convErrDef = newNode(nkLetSection).addChain( - newIdentDefs(ident("convErr"), newNode(nkEmpty), - newCall("fromGodot", ident("result"), newCall("newVariant", retValIdent)))) - let convCheck = newIfStmt( - newInfix(ident("convErr"), ident("!="), - newDotExpr(ident("ConversionResult"), ident("OK"))), - newNode(nkRaiseStmt).addChain( - newCall("newConversionError", ident("convErr"))) - ) - body.add(convErrDef) - body.add(convCheck) - if isStringRet: - body.add(newCall("deinit", retValIdent)) - elif isConversionRet: - body.add(newNode(nkAsgn).addChain( - ident("result"), - newCall(returnType, retValIdent))) - elif isWrapperRet: - body.add(newNode(nkAsgn).addChain( - ident("result"), - newCall("new" & returnType, retValIdent))) - elif isObjRet: - body.add(newNode(nkAsgn).addChain(ident("result"), - newCall(newBracketExpr(ident("asNimGodotObject"), - newCall("type", ident("result"))), retValIdent))) - elif isStringRet: - body.add(newNode(nkAsgn).addChain(ident("result"), - newCall("$", retValIdent))) - - let procType = if isVirtual: nkMethodDef - else: nkProcDef - var params = newSeqOfCap[PNode](args.len + 2) - if not returnType.isNil: - params.add(ident(returnType)) - else: - params.add(newNode(nkEmpty)) - if not typ.isSingleton: - params.add(newIdentDefs(ident("self"), ident(toNimType(typ.name)))) - - for arg in args: - if arg.isVarargs: - params.add(newIdentDefs(ident(arg.name), - newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) - else: - let defaultValue = arg.makeDefaultValue() - params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue)) - let procDecl = newProc(if not withImplementation: postfix(name, "*") - else: name, - params, body, procType) - if not withImplementation: - let pragma = newNode(nkPragma) - pragma.add(ident("gcsafe")) - pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"), - newIntLit(0))) - if isVirtual and isBase: - pragma.add(ident("base")) - procDecl.sons[4] = pragma - tree.add(procDecl) - -proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string], - name: PNode, godotMethodName: string, - typ: GodotType, args: seq[MethodArg], - returnType: string, - isVirtual, isBase, withImplementation: bool) = - doGenerateMethod( - tree, methodBindRegistry, name, godotMethodName, typ, - args, returnType, isVirtual, isBase, withImplementation) - -proc makeProperty(types: Table[string, GodotType], tree: PNode, - methodBindRegistry: var HashSet[string], - typ: GodotType, - propertyObj: JsonNode, withImplementation: bool) = - let getterNameStr = toNimStyle(propertyObj["name"].str) - let getterName = ident(toNimStyle(propertyObj["name"].str)) - let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) - - let nimType = toNimType(types, propertyObj["type"].str) - generateMethod(tree, methodBindRegistry, - getterName, propertyObj["getter"].str, typ, - @[], nimType, isVirtual = false, - isBase = false, withImplementation) - generateMethod(tree, methodBindRegistry, - setterName, propertyObj["setter"].str, typ, - @[("val", nimType, JsonNode(nil), false)], - nil, isVirtual = false, isBase = false, withImplementation) - -proc makeMethod(types: Table[string, GodotType], tree: PNode, - methodBindRegistry: var HashSet[string], - typ: GodotType, methodObj: JsonNode, - withImplementation: bool) = - let returnType = if methodObj["return_type"].str != "void": - toNimType(types, methodObj["return_type"].str) - else: nil - - for prop in typ.jsonNode["properties"]: - if prop["getter"].str == methodObj["name"].str or - prop["setter"].str == methodObj["name"].str: - return - - var args = newSeqOfCap[MethodArg](methodObj["arguments"].len + 1) - var origArgs = methodObj["arguments"] - var isBase = methodObj["is_virtual"].bval - if methodObj["is_virtual"].bval: - proc getMethod(typNode: JsonNode, methName: string): JsonNode = - for meth in typNode["methods"]: - if meth["is_virtual"].bval and - meth["name"].str == methName: return meth - var curTyp = types.getOrDefault(typ.baseName) - while not curTyp.isNil: - let meth = curTyp.jsonNode.getMethod(methodObj["name"].str) - if not meth.isNil: - origArgs = meth["arguments"] - isBase = false - curTyp = types.getOrDefault(curTyp.baseName) - - for arg in origArgs: - let typ = toNimType(types, arg["type"].str) - let defaultVal = if arg["has_default_value"].bval: arg["default_value"] - else: nil - args.add((toNimStyle(arg["name"].str), typ, - defaultVal, false)) - if methodObj["has_varargs"].bval: - args.add(("variantArgs", "Variant", JsonNode(nil), true)) - - let godotName = methodObj["name"].str - var nimName = toNimStyle(godotName) - if not godotName.startsWith('_'): - for meth in typ.jsonNode["methods"]: - if meth["name"].str == '_' & godotName: - nimName = nimName & "Impl" - - generateMethod(tree, methodBindRegistry, - ident(nimName), methodObj["name"].str, - typ, args, - returnType, methodObj["is_virtual"].bval, isBase, - withImplementation) - -proc addAttributeToDoc(doc: var string, propName, propValue: string) = - if doc.len > 0: - doc.add("\n") - doc.add(propName & ": " & propValue) - -const classAttributes = ["singleton", "instanciable", "is_reference"] - -proc typeNameToModuleName(name: string): string = - var wasUpperOrDigit = true - result = newStringOfCap(name.len + 10) - for idx, c in name: - if c.isUpperAscii() or c.isDigit(): - if not wasUpperOrDigit or idx > 0 and idx < name.len - 1 and - name[idx + 1].isLowerAscii(): - result.add('_') - result.add(c.toLowerAscii()) - wasUpperOrDigit = true - else: - result.add(c) - wasUpperOrDigit = false - if result == "object": - # keyword - result = "objects" - if result == "os": - # to avoid clash with stdlib - result = "gd_os" - -proc newRegisterClassNode(typ: GodotType): PNode = - newCall("registerClass", - ident(typ.name), - newCStringLit(typ.godotName), - ident("true") # isNative - ) - -proc genSingletonDecl(typ: string): PNode = - result = newNode(nkVarSection) - let name = singletonName(typ) - let threadvar = newNode(nkPragma).addChain(ident("threadvar")) - result.add(newIdentDefs(newNode(nkPragmaExpr).addChain(name, threadvar), - ident(typ))) - -proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool = - var curTyp = typ - while not curTyp.isNil and not curTyp.isSingleton: - curTyp = types.getOrDefault(curTyp.baseName) - result = curTyp.isNil - -proc genTypeFile*(types: var Table[string, GodotType], targetDir: string) = - for typ in types.values(): - types.incDerivedCount(typ.baseName) - - var sortedTypes = toSeq(types.values()) - sortedTypes.sort do (x, y: GodotType) -> int: - cmp(y.derivedCount, x.derivedCount) - - let godotApiTypesTree = newNode(nkStmtList) - godotApiTypesTree.add(newNode(nkImportStmt).addChain(ident("godot"))) - let typeSection = newNode(nkTypeSection) - godotApiTypesTree.add(typeSection) - - for typ in sortedTypes: - if not typ.shouldExport(types): continue - newRefTypeNode(typeSection, typ.name, typ.baseName, typ.doc) - - for typ in sortedTypes: - if not typ.shouldExport(types): continue - let regNode = newCall("registerClass", - ident(typ.name), - newCStringLit(typ.godotName), - ident("true") # isNative - ) - godotApiTypesTree.add(regNode) - - renderModule(godotApiTypesTree, targetDir / "godottypes.nim") - -proc genApi*(targetDir: string, apiJsonFile: string) = - let apiJson = parseJson(newFileStream(apiJsonFile), - apiJsonFile.extractFilename()) - var megaImport = newStringOfCap(64 * 1024) - - var types = initTable[string, GodotType]() - for obj in apiJson: - let godotClassName = obj["name"].str - let className = godotClassName.replace("_", "") - var baseClassName = obj["base_class"].str - baseClassName = toNimType(baseClassName.replace("_", "")) - if baseClassName.isNil or baseClassName.len == 0: - baseClassName = "NimGodotObject" - var doc = "" - for attr in classAttributes: - if attr in obj: - addAttributeToDoc(doc, attr, $obj[attr]) - types[className] = GodotType( - name: className, - godotName: godotClassName, - baseName: baseClassName, - doc: doc, - jsonNode: obj, - isSingleton: obj["singleton"].bval - ) - for typ in types.values(): - let tree = newNode(nkStmtList) - let importStmt = newNode(nkImportStmt) - importStmt.add(ident("godot")) - importStmt.add(ident("godottypes")) - importStmt.add(ident("godotinternal")) - tree.add(importStmt) - let exportStmt = newNode(nkExportStmt) - exportStmt.add(ident("godottypes")) - tree.add(exportStmt) - - var methodBindRegsitry = initSet[string]() - let obj = typ.jsonNode - if typ.baseName != "NimGodotObject": - let baseModule = typeNameToModuleName(typ.baseName) - let baseModuleNode = if getIdent(baseModule).isKeyword: - newStrLit(baseModule & ".nim") - else: - ident(baseModule) - importStmt.add(baseModuleNode) - exportStmt.add(baseModuleNode) - let constSection = makeConstSection(obj["constants"]) - if constSection.kind != nkEmpty: - # renderer doesn't properly render empty stmt after type section - tree.add(makeConstSection(obj["constants"])) - - if typ.isSingleton: - let typeDecl = newNode(nkTypeSection) - newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc, - isExported = false) - tree.add(typeDecl) - tree.add(newRegisterClassNode(typ)) - tree.add(genSingletonDecl(typ.name)) - - # first, generate declarations only for ease of - # human readability of the file - for property in obj["properties"]: - makeProperty(types, tree, methodBindRegsitry, typ, property, - withImplementation = false) - for meth in obj["methods"]: - makeMethod(types, tree, methodBindRegsitry, typ, - meth, withImplementation = false) - - for property in obj["properties"]: - makeProperty(types, tree, methodBindRegsitry, typ, - property, withImplementation = true) - for meth in obj["methods"]: - makeMethod(types, tree, methodBindRegsitry, typ, meth, - withImplementation = true) - - let moduleName = typeNameToModuleName(typ.name) - renderModule(tree, targetDir / moduleName & ".nim") - - megaImport.add("import \"" & moduleName & "\"\n") - - genTypeFile(types, targetDir) - - writeFile(targetDir / "godotall.nim", megaImport) - writeFile(targetDir / splitPath(targetDir)[1] & ".nimble", "") - -when isMainModule: - import os - - const usage = slurp("usage.txt") - - proc main() = - if paramCount() < 2: - echo usage - quit(-1) - let godotBin = paramStr(1) - let targetDir = paramStr(2) - - if not dirExists(targetDir): - echo "The specified directory does not exist" - quit(-1) - if not fileExists(godotBin): - echo "Invalid godot binary path" - quit(-1) - - let jsonFile = targetDir / "api.json" - if fileExists(jsonFile) and - godotBin.getLastModificationTime() <= jsonFile.getLastModificationTime(): - echo "api.json if up to date - doing nothing." - return - - discard execShellCmd( - "\"" & godotBin & "\" --gdnative-generate-json-api \"" & jsonFile & "\"") - if not fileExists(jsonFile): - echo "Failed to generate api.json" - quit(-1) - - genApi(targetDir, jsonFile) - - main() +include "../godotapigen.nim" \ No newline at end of file diff --git a/godot/apigen/usage.txt b/godot/apigen/usage.txt deleted file mode 100644 index 566634c..0000000 --- a/godot/apigen/usage.txt +++ /dev/null @@ -1,3 +0,0 @@ -Tool for wrapping Godot API into Nim - - apigen [godot binary path] [target directory] \ No newline at end of file diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim new file mode 100644 index 0000000..7549624 --- /dev/null +++ b/godot/godotapigen.nim @@ -0,0 +1,877 @@ +# Copyright 2017 Xored Software, Inc. + +import streams, json, ospaths, strutils, times, sets, tables +import sequtils, algorithm +import compiler / [ast, renderer, idents, astalgo] + +proc ident(ident: string): PNode = + result = newNode(nkIdent) + result.ident = getIdent(ident) + +proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} = + for other in others: + node.add(other) + result = node + +proc newIdentDefs(name, typ: PNode, + defaultVal: PNode = nil): PNode = + result = newNode(nkIdentDefs) + result.add(name) + result.add(typ) + if defaultVal.isNil: + result.add(newNode(nkEmpty)) + else: + result.add(defaultVal) + +proc newProc(name: PNode, params: openArray[PNode], body = newNode(nkEmpty), + procType = nkProcDef): PNode = + result = newNode(procType) + result.add(name) + result.add(newNode(nkEmpty)) + result.add(newNode(nkEmpty)) + let formalParams = newNode(nkFormalParams) + for param in params: + formalParams.add(param) + result.add(formalParams) + result.add(newNode(nkEmpty)) + result.add(newNode(nkEmpty)) + result.add(body) + +proc newIfStmt(condition, body: PNode): PNode = + result = newNode(nkIfStmt) + let branch = newNode(nkElifBranch) + result.add(branch) + branch.add(condition) + branch.add(body) + +proc newCall(theProc: PNode, args: varargs[PNode]): PNode = + result = newNode(nkCall) + result.add(theProc) + for arg in args: + result.add(arg) + +proc newCall(theProc: string, args: varargs[PNode]): PNode = + newCall(ident(theProc), args) + +proc newStrLit(s: string): PNode = + result = newNode(nkStrLit) + result.strVal = s + +proc newRStrLit(s: string): PNode = + result = newNode(nkRStrLit) + result.strVal = s + +proc newCStringLit(s: string): PNode = + newNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s)) + +proc newIntLit(val: BiggestInt): PNode = + result = newNode(nkIntLit) + result.intVal = val + +proc newInt64Lit(val: BiggestInt): PNode = + result = newNode(nkInt64Lit) + result.intVal = val + +proc newFloatLit(val: BiggestFloat): PNode = + result = newNode(nkFloatLit) + result.floatVal = val + +proc newFloat64Lit(val: BiggestFloat): PNode = + result = newNode(nkFloat64Lit) + result.floatVal = val + +proc newNilLit(): PNode = + result = newNode(nkNilLit) + +proc newDotExpr(left, right: PNode): PNode = + result = newNode(nkDotExpr) + result.add(left) + result.add(right) + +proc newCommand(left, right: PNode): PNode = + result = newNode(nkCommand) + result.add(left) + result.add(right) + +proc newInfix(left, op, right: PNode): PNode = + result = newNode(nkInfix) + result.add(op) + result.add(left) + result.add(right) + +proc postfix(left: PNode, op: string): PNode = + result = newNode(nkPostfix) + result.add(ident(op)) + result.add(left) + +proc newBracketExpr(first, bracket: PNode): PNode = + newNode(nkBracketExpr).addChain(first, bracket) + +proc newEmptyNode(): PNode = + newNode(nkEmpty) + +type GodotType = ref object + name: string + godotName: string + baseName: string + doc: string + derivedCount: int + isSingleton: bool + jsonNode: JsonNode + +proc findCommonRoot(typeRegistry: Table[string, GodotType], + types: seq[string]): string = + if types.len == 0: return "Object" + var chains = newSeq[seq[string]](types.len) + for idx, typ in types: + chains[idx] = newSeq[string]() + chains[idx].add(typ) + var curTyp = typeRegistry[typ] + while curTyp.baseName != "NimGodotObject": + chains[idx].add(curTyp.baseName) + curTyp = typeRegistry[curTyp.baseName] + chains[idx].reverse() + + var idx = 0 + while true: + var curType: string + var allEqual = true + for chain in chains: + if idx >= chain.len: + allEqual = false + break + if curType.isNil: + curType = chain[idx] + elif curType != chain[idx]: + allEqual = false + break + if allEqual: + result = curType + else: + break + inc idx + +proc incDerivedCount(types: var Table[string, GodotType], + className: string) = + let typ = types.getOrDefault(className) + if not typ.isNil: + inc typ.derivedCount + types.incDerivedCount(typ.baseName) + +proc toNimType(godotType: string): string = + case godotType: + of "float": "float64" + of "int": "int64" + of "String": "string" + of "File": "godottypes.File" + else: godotType + +proc toNimType(types: Table[string, GodotType], godotType: string): string = + let origType = + if godotType.contains(','): + findCommonRoot(types, godotType.split(',')) + else: + godotType + result = toNimType(origType) + +proc toNimStyle(name: string): string = + result = newStringOfCap(name.len + 1) + var i = 0 + var makeUpperCase: bool + while i < name.len: + if name[i] == '_': + if result.len != 0: + makeUpperCase = true + elif name[i] != '/': # remove slashes + if makeUpperCase: + result.add(name[i].toUpperAscii()) + makeUpperCase = false + else: + result.add(name[i]) + inc i + + while isKeyword(getIdent(result)): + result.add(result[result.len - 1]) + + if result == "result": + result = "resultVal" + +proc newRefTypeNode(typeSection: PNode, typ, base, doc: string, + isExported = true) = + let typeDef = newNode(nkTypeDef) + typeSection.add(typeDef) + if isExported: + typeDef.add(postfix(ident(typ), "*")) + else: + typeDef.add(ident(typ)) + + typeDef.add(newNode(nkEmpty)) # generic + let objTy = newNode(nkObjectTy) + let refTy = newNode(nkRefTy) + refTy.add(objTy) + typeDef.add(refTy) + + objTy.add(newNode(nkEmpty)) + let inherit = newNode(nkOfInherit) + inherit.add(ident(base)) + objTy.add(inherit) + + if not doc.isNil: + let recList = newNode(nkRecList) + let docNode = newNode(nkCommentStmt) + docNode.comment = doc + recList.add(docNode) + objTy.add(recList) + else: + objTy.add(newNode(nkEmpty)) + +proc makeConstSection(constObj: JsonNode): PNode = + if constObj.len == 0: + return newNode(nkEmpty) + + result = newNode(nkConstSection) + for field, val in constObj: + let def = newNode(nkConstDef) + def.add(postfix(ident(field), "*")) + def.add(newNode(nkEmpty)) # infer type + var valNode: PNode + if val.kind == JInt: + valNode = newInt64Lit(val.num) + # valNode.intVal = val.num + elif val.kind == JFloat: + valNode = newFloat64Lit(val.fnum) + elif val.kind == JBool: + valNode = ident($val.bval) + elif val.kind == JString: + valNode = newNode(nkStrLit) + valNode.strVal = val.str + else: + raise newException(ValueError, "Unexpected constant kind: " & $val.kind) + def.add(valNode) + result.add(def) + +type MethodArg = tuple[name, typ: string, defaultVal: JsonNode, isVarargs: bool] + +const standardTypes = toSet( + ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", + "uint64", + "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", + "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform", + "Color", "RID", "NodePath", "Dictionary", "Variant", "Array", + "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", + "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) + +const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32", + "cint", "int", "Error"]) +const int64Types = toSet(["uint64", "int64"]) +const intTypes = union(smallIntTypes, int64Types) +const float64Types = toSet(["float64", "cdouble"]) +const float32Types = toSet(["float32", "cfloat"]) +const floatTypes = union(float64Types, float32Types) +const arrayTypes = toSet(["Array", "PoolByteArray", + "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", + "PoolVector3Array", "PoolColorArray"]) +const wrapperTypes = union(arrayTypes, + toSet(["NodePath", "Dictionary", "Variant"])) + +proc getInternalPtr(varName: PNode, typ: string): PNode = + assert(typ in wrapperTypes) + result = newDotExpr(varName, ident("godot" & typ)) + +proc newNilCheck(ident, toAssign: PNode): PNode = + newIfStmt(newCall("isNil", ident), + newNode(nkAsgn).addChain(ident).addChain( + toAssign + ) + ) + +proc singletonName(typ: string): PNode = + ident("singleton" & typ) + +proc makeDefaultValue(arg: MethodArg): PNode = + result = newEmptyNode() + if not arg.defaultVal.isNil: + if arg.typ == "bool": + result = ident(arg.defaultVal.str.toLowerAscii()) + elif arg.typ in intTypes: + result = newInt64Lit(parseBiggestInt(arg.defaultVal.str)) + elif arg.typ == "string" or arg.typ == "NodePath": + result = newStrLit(arg.defaultVal.str) + elif arg.typ in floatTypes: + result = newFloatLit(parseFloat(arg.defaultVal.str)) + elif arg.defaultVal.str == "Null": + if arg.typ == "Variant": + result = newCall("newVariant") + else: + result = newNilLit() + elif arg.typ == "Color": + result = newCall("initColor", + arg.defaultVal.str.split(',').mapIt(newFloatLit(parseFloat(it)))) + # elif arg.typ in arrayTypes and (arg.defaultVal.str == "[]" or + # arg.defaultVal.str == "[" & arg.typ & "]"): + # result = newCall("init" & arg.typ) + elif arg.typ == "RID" and arg.defaultVal.str == "[RID]": + result = newCall("initRID") + elif arg.typ == "Vector2" or arg.typ == "Vector3" or arg.typ == "Rect2": + let parts = arg.defaultVal.str.replace("(", "").replace(")", ""). + replace(" ", ""). + split(",").mapIt(newFloatLit(parseFloat(it))) + if arg.typ.endsWith("r2"): + result = newCall("vec2", parts) + elif arg.typ.endsWith('3'): + result = newCall("vec3", parts) + else: + result = newCall("initRect2", parts) + elif arg.defaultVal.str == "[Object:null]": + result = newNilLit() + elif arg.typ != "Transform" and arg.typ != "Transform2D" and + arg.typ != "Variant" and arg.typ notin arrayTypes: # TODO + raise newException( + ValueError, + "Cannot build default value from $# ($#)" % + [$arg.defaultVal, arg.typ]) + +proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], + name: PNode, godotMethodName: string, + typ: GodotType, args: seq[MethodArg], + returnType: string, isVirtual, + isBase, withImplementation: bool) = + var body: PNode + if not withImplementation: + body = newNode(nkEmpty) + else: + var methodBindName = toNimStyle( + typ.name & "_" & godotMethodName & "_method_bind") + if methodBindName[0].isUpperAscii(): + methodBindName[0] = methodBindName[0].toLowerAscii() + if methodBindName notin methodBindRegistry: + let methodBindDecl = newNode(nkVarSection).addChain( + newIdentDefs( + newNode(nkPragmaExpr).addChain( + ident(methodBindName)).addChain( + newNode(nkPragma).addChain(ident("threadvar"))), + newNode(nkPtrTy).addChain(ident("GodotMethodBind")) + )) + tree.add(methodBindDecl) + methodBindRegistry.incl(methodBindName) + + let nilCheck = newNilCheck(ident(methodBindName), + newCall("getMethod", newCStringLit(typ.godotName), + newCStringLit(godotMethodName)) + ) + let vars = newNode(nkVarSection) + var varargsName: string + var isVarargs: bool + var staticArgsLen: int + var argLenNode = newIntLit(0) + let argsName = ident("argsToPassToGodot") + if args.len > 0: + for arg in args: + if arg.isVarargs: + varargsName = arg.name + isVarargs = true + vars.add(newIdentDefs(ident("callError"), ident("VariantCallError"))) + break + let argsAlloc = newNode(nkCast).addChain( + newNode(nkPtrTy).addChain( + newNode(nkBracketExpr).addChain( + ident("array"), ident("MAX_ARG_COUNT"), + if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) + else: ident("pointer")))) + staticArgsLen = if varargsName.isNil: args.len + else: args.len - 1 + if not varargsName.isNil: + argLenNode = newCall("cint", + newInfix(newIntLit(staticArgsLen), + ident("+"), + newDotExpr(ident(varargsName), ident("len")))) + argsAlloc.add(newCall("godotAlloc", newCall("cint", newInfix( + newCall("sizeof", ident("Variant")), ident("*"), + newNode(nkPar).addChain(argLenNode)))) + ) + else: + argLenNode = newCall("cint", newIntLit(staticArgsLen)) + vars.add(newIdentDefs( + ident("argsStatic"), + newNode(nkBracketExpr).addChain( + ident("array"), newIntLit(staticArgsLen), ident("pointer")), + newNode(nkEmpty))) + argsAlloc.add(newCommand(ident("addr"), ident("argsStatic"))) + vars.add(newIdentDefs(argsName, newNode(nkEmpty), argsAlloc)) + + let argConversions = newNode(nkStmtList) + for idx, arg in args: + var argName = ident(arg.name) + if arg.isVarargs: + argName = newNode(nkBracketExpr).addChain( + ident(varargsName), + newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) + let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx) + let isStandardType = arg.typ in standardTypes + let isWrappedType = arg.typ in wrapperTypes + let convArg = if not varargsName.isNil: + getInternalPtr(newCall("toGodot", argName), "Variant") + elif isWrappedType: getInternalPtr(argName, arg.typ) + elif isStandardType: newCall("unsafeAddr", argName) + elif arg.typ == "string": newCall("unsafeAddr", + ident("argToPassToGodot" & $idx)) + else: ident("argToPassToGodot" & $idx) # object + if not isStandardType and arg.isVarargs: + raise newException(ValueError, + "Non-standard type $# for varargs params of method $# of type $#" % + [arg.typ, godotMethodName, typ.godotName]) + if not isStandardType and varargsName.isNil: + if arg.typ == "string": + argConversions.add(newNode(nkVarSection).addChain( + newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), + newCall("toGodotString", argName)))) + else: + argConversions.add(newNode(nkLetSection).addChain( + newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), + newDotExpr(argName, ident("godotObject"))))) + let argAsgn = newNode(nkAsgn).addChain( + newNode(nkBracketExpr).addChain( + newNode(nkBracketExpr).addChain(argsName), argIdx), + convArg + ) + if not arg.isVarargs: + argConversions.add( + argAsgn + ) + else: + argConversions.add(newNode(nkVarSection).addChain( + newIdentDefs(ident("idx"), newNode(nkEmpty), newIntLit(staticArgsLen)))) + let argLoop = newNode(nkWhileStmt) + argConversions.add(argLoop) + argLoop.add(newInfix(ident("idx"), ident("<"), argLenNode) + ) + argLoop.add(newNode(nkStmtList).addChain( + argAsgn, + newCommand(ident("inc"), ident("idx")))) + + let retName = if isVarargs: "callRet" else: "ptrCallRet" + let theCall = newCall( + newDotExpr(ident(methodBindName), + ident(if isVarargs: "call" else: "ptrCall")), + newDotExpr(ident("self"), ident("godotObject")), + if args.len > 0: argsName else: newNode(nkNilLit), + argLenNode, + if not isVarargs: ident(retName) else: ident("callError") + ) + if not isVarargs: + theCall.sons.delete(3) + let freeCall = newCall("godotFree", argsName) + body = newNode(nkStmtList) + if typ.isSingleton: + let varName = singletonName(typ.name) + body.add(newNilCheck(varName, newCall( + newBracketExpr(ident("getSingleton"), ident(typ.name))))) + body.add(newNode(nkLetSection).addChain(newIdentDefs( + ident("self"), newNode(nkEmpty), varName + ))) + body.add(nilCheck) + body.add(vars) + body.add(argConversions) + if not isVarargs: + let retPtrDecl = newNode(nkVarSection).addChain( + newIdentDefs(ident(retName), ident("pointer"), newEmptyNode()) + ) + body.add(retPtrDecl) + var isVariantRet: bool + var isConversionRet: bool + var isObjRet: bool + var isStringRet: bool + var isWrapperRet: bool + let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName) + if not returnType.isNil and not isVarargs: + var addrToAssign = newCall("addr", retValIdent) + if returnType in smallIntTypes: + isConversionRet = true + body.add(newNode(nkVarSection).addChain(newIdentDefs( + retValIdent, ident("int64"), + ))) + elif returnType in float32Types: + isConversionRet = true + body.add(newNode(nkVarSection).addChain(newIdentDefs( + retValIdent, ident("float64"), + ))) + elif returnType in wrapperTypes: + isWrapperRet = true + body.add(newNode(nkVarSection).addChain(newIdentDefs( + retValIdent, ident("Godot" & returnType), + ))) + elif returnType in standardTypes: + addrToAssign = newCall("addr", ident("result")) + elif returnType == "string": + isStringRet = true + body.add(newNode(nkVarSection).addChain(newIdentDefs( + retValIdent, ident("GodotString"), + ))) + else: + isObjRet = true + body.add(newNode(nkVarSection).addChain(newIdentDefs( + retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")), + ))) + body.add(newNode(nkAsgn).addChain(ident(retName), addrToAssign)) + + if not isVarargs: + body.add(theCall) + else: + if not returnType.isNil: + isVariantRet = true + let callStmt = newNode(nkLetSection).addChain( + newIdentDefs( + newNode(nkPragmaExpr).addChain( + ident(retName), newNode(nkPragma).addChain(ident("used"))), + newNode(nkEmpty), theCall)) + body.add(callStmt) + + if varargsName.isNil: + for idx, arg in args: + if arg.typ == "string": + body.add(newCall("deinit", ident("argToPassToGodot" & $idx))) + + if args.len > 0 and not varargsName.isNil: + body.add(freeCall) + if not varargsName.isNil: + let errCheck = newIfStmt( + newInfix(newDotExpr(ident("callError"), ident("error")), ident("!="), + newDotExpr(ident("VariantCallErrorType"), ident("OK"))), + newNode(nkRaiseStmt).addChain( + newCall("newCallError", ident("callError"))) + ) + body.add(errCheck) + if isVariantRet: + let convErrDef = newNode(nkLetSection).addChain( + newIdentDefs(ident("convErr"), newNode(nkEmpty), + newCall("fromGodot", ident("result"), newCall("newVariant", retValIdent)))) + let convCheck = newIfStmt( + newInfix(ident("convErr"), ident("!="), + newDotExpr(ident("ConversionResult"), ident("OK"))), + newNode(nkRaiseStmt).addChain( + newCall("newConversionError", ident("convErr"))) + ) + body.add(convErrDef) + body.add(convCheck) + if isStringRet: + body.add(newCall("deinit", retValIdent)) + elif isConversionRet: + body.add(newNode(nkAsgn).addChain( + ident("result"), + newCall(returnType, retValIdent))) + elif isWrapperRet: + body.add(newNode(nkAsgn).addChain( + ident("result"), + newCall("new" & returnType, retValIdent))) + elif isObjRet: + body.add(newNode(nkAsgn).addChain(ident("result"), + newCall(newBracketExpr(ident("asNimGodotObject"), + newCall("type", ident("result"))), retValIdent))) + elif isStringRet: + body.add(newNode(nkAsgn).addChain(ident("result"), + newCall("$", retValIdent))) + + let procType = if isVirtual: nkMethodDef + else: nkProcDef + var params = newSeqOfCap[PNode](args.len + 2) + if not returnType.isNil: + params.add(ident(returnType)) + else: + params.add(newNode(nkEmpty)) + if not typ.isSingleton: + params.add(newIdentDefs(ident("self"), ident(toNimType(typ.name)))) + + for arg in args: + if arg.isVarargs: + params.add(newIdentDefs(ident(arg.name), + newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) + else: + let defaultValue = arg.makeDefaultValue() + params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue)) + let procDecl = newProc(if not withImplementation: postfix(name, "*") + else: name, + params, body, procType) + if not withImplementation: + let pragma = newNode(nkPragma) + pragma.add(ident("gcsafe")) + pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"), + newIntLit(0))) + if isVirtual and isBase: + pragma.add(ident("base")) + procDecl.sons[4] = pragma + tree.add(procDecl) + +proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string], + name: PNode, godotMethodName: string, + typ: GodotType, args: seq[MethodArg], + returnType: string, + isVirtual, isBase, withImplementation: bool) = + doGenerateMethod( + tree, methodBindRegistry, name, godotMethodName, typ, + args, returnType, isVirtual, isBase, withImplementation) + +proc makeProperty(types: Table[string, GodotType], tree: PNode, + methodBindRegistry: var HashSet[string], + typ: GodotType, + propertyObj: JsonNode, withImplementation: bool) = + let getterNameStr = toNimStyle(propertyObj["name"].str) + let getterName = ident(toNimStyle(propertyObj["name"].str)) + let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) + + let nimType = toNimType(types, propertyObj["type"].str) + generateMethod(tree, methodBindRegistry, + getterName, propertyObj["getter"].str, typ, + @[], nimType, isVirtual = false, + isBase = false, withImplementation) + generateMethod(tree, methodBindRegistry, + setterName, propertyObj["setter"].str, typ, + @[("val", nimType, JsonNode(nil), false)], + nil, isVirtual = false, isBase = false, withImplementation) + +proc makeMethod(types: Table[string, GodotType], tree: PNode, + methodBindRegistry: var HashSet[string], + typ: GodotType, methodObj: JsonNode, + withImplementation: bool) = + let returnType = if methodObj["return_type"].str != "void": + toNimType(types, methodObj["return_type"].str) + else: nil + + for prop in typ.jsonNode["properties"]: + if prop["getter"].str == methodObj["name"].str or + prop["setter"].str == methodObj["name"].str: + return + + var args = newSeqOfCap[MethodArg](methodObj["arguments"].len + 1) + var origArgs = methodObj["arguments"] + var isBase = methodObj["is_virtual"].bval + if methodObj["is_virtual"].bval: + proc getMethod(typNode: JsonNode, methName: string): JsonNode = + for meth in typNode["methods"]: + if meth["is_virtual"].bval and + meth["name"].str == methName: return meth + var curTyp = types.getOrDefault(typ.baseName) + while not curTyp.isNil: + let meth = curTyp.jsonNode.getMethod(methodObj["name"].str) + if not meth.isNil: + origArgs = meth["arguments"] + isBase = false + curTyp = types.getOrDefault(curTyp.baseName) + + for arg in origArgs: + let typ = toNimType(types, arg["type"].str) + let defaultVal = if arg["has_default_value"].bval: arg["default_value"] + else: nil + args.add((toNimStyle(arg["name"].str), typ, + defaultVal, false)) + if methodObj["has_varargs"].bval: + args.add(("variantArgs", "Variant", JsonNode(nil), true)) + + let godotName = methodObj["name"].str + var nimName = toNimStyle(godotName) + if not godotName.startsWith('_'): + for meth in typ.jsonNode["methods"]: + if meth["name"].str == '_' & godotName: + nimName = nimName & "Impl" + + generateMethod(tree, methodBindRegistry, + ident(nimName), methodObj["name"].str, + typ, args, + returnType, methodObj["is_virtual"].bval, isBase, + withImplementation) + +proc addAttributeToDoc(doc: var string, propName, propValue: string) = + if doc.len > 0: + doc.add("\n") + doc.add(propName & ": " & propValue) + +const classAttributes = ["singleton", "instanciable", "is_reference"] + +proc typeNameToModuleName(name: string): string = + var wasUpperOrDigit = true + result = newStringOfCap(name.len + 10) + for idx, c in name: + if c.isUpperAscii() or c.isDigit(): + if not wasUpperOrDigit or idx > 0 and idx < name.len - 1 and + name[idx + 1].isLowerAscii(): + result.add('_') + result.add(c.toLowerAscii()) + wasUpperOrDigit = true + else: + result.add(c) + wasUpperOrDigit = false + if result == "object": + # keyword + result = "objects" + if result == "os": + # to avoid clash with stdlib + result = "gd_os" + +proc newRegisterClassNode(typ: GodotType): PNode = + newCall("registerClass", + ident(typ.name), + newCStringLit(typ.godotName), + ident("true") # isNative + ) + +proc genSingletonDecl(typ: string): PNode = + result = newNode(nkVarSection) + let name = singletonName(typ) + let threadvar = newNode(nkPragma).addChain(ident("threadvar")) + result.add(newIdentDefs(newNode(nkPragmaExpr).addChain(name, threadvar), + ident(typ))) + +proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool = + var curTyp = typ + while not curTyp.isNil and not curTyp.isSingleton: + curTyp = types.getOrDefault(curTyp.baseName) + result = curTyp.isNil + +proc genTypeFile*(types: var Table[string, GodotType], targetDir: string) = + for typ in types.values(): + types.incDerivedCount(typ.baseName) + + var sortedTypes = toSeq(types.values()) + sortedTypes.sort do (x, y: GodotType) -> int: + cmp(y.derivedCount, x.derivedCount) + + let godotApiTypesTree = newNode(nkStmtList) + godotApiTypesTree.add(newNode(nkImportStmt).addChain(ident("godot"))) + let typeSection = newNode(nkTypeSection) + godotApiTypesTree.add(typeSection) + + for typ in sortedTypes: + if not typ.shouldExport(types): continue + newRefTypeNode(typeSection, typ.name, typ.baseName, typ.doc) + + for typ in sortedTypes: + if not typ.shouldExport(types): continue + let regNode = newCall("registerClass", + ident(typ.name), + newCStringLit(typ.godotName), + ident("true") # isNative + ) + godotApiTypesTree.add(regNode) + + renderModule(godotApiTypesTree, targetDir / "godottypes.nim") + +proc genApi*(targetDir: string, apiJsonFile: string) = + let apiJson = parseJson(newFileStream(apiJsonFile), + apiJsonFile.extractFilename()) + var megaImport = newStringOfCap(64 * 1024) + + var types = initTable[string, GodotType]() + for obj in apiJson: + let godotClassName = obj["name"].str + let className = godotClassName.replace("_", "") + var baseClassName = obj["base_class"].str + baseClassName = toNimType(baseClassName.replace("_", "")) + if baseClassName.isNil or baseClassName.len == 0: + baseClassName = "NimGodotObject" + var doc = "" + for attr in classAttributes: + if attr in obj: + addAttributeToDoc(doc, attr, $obj[attr]) + types[className] = GodotType( + name: className, + godotName: godotClassName, + baseName: baseClassName, + doc: doc, + jsonNode: obj, + isSingleton: obj["singleton"].bval + ) + for typ in types.values(): + let tree = newNode(nkStmtList) + let importStmt = newNode(nkImportStmt) + importStmt.add(ident("godot")) + importStmt.add(ident("godottypes")) + importStmt.add(ident("godotinternal")) + tree.add(importStmt) + let exportStmt = newNode(nkExportStmt) + exportStmt.add(ident("godottypes")) + tree.add(exportStmt) + + var methodBindRegsitry = initSet[string]() + let obj = typ.jsonNode + if typ.baseName != "NimGodotObject": + let baseModule = typeNameToModuleName(typ.baseName) + let baseModuleNode = if getIdent(baseModule).isKeyword: + newStrLit(baseModule & ".nim") + else: + ident(baseModule) + importStmt.add(baseModuleNode) + exportStmt.add(baseModuleNode) + let constSection = makeConstSection(obj["constants"]) + if constSection.kind != nkEmpty: + # renderer doesn't properly render empty stmt after type section + tree.add(makeConstSection(obj["constants"])) + + if typ.isSingleton: + let typeDecl = newNode(nkTypeSection) + newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc, + isExported = false) + tree.add(typeDecl) + tree.add(newRegisterClassNode(typ)) + tree.add(genSingletonDecl(typ.name)) + + # first, generate declarations only for ease of + # human readability of the file + for property in obj["properties"]: + makeProperty(types, tree, methodBindRegsitry, typ, property, + withImplementation = false) + for meth in obj["methods"]: + makeMethod(types, tree, methodBindRegsitry, typ, + meth, withImplementation = false) + + for property in obj["properties"]: + makeProperty(types, tree, methodBindRegsitry, typ, + property, withImplementation = true) + for meth in obj["methods"]: + makeMethod(types, tree, methodBindRegsitry, typ, meth, + withImplementation = true) + + let moduleName = typeNameToModuleName(typ.name) + renderModule(tree, targetDir / moduleName & ".nim") + + megaImport.add("import \"" & moduleName & "\"\n") + + genTypeFile(types, targetDir) + + writeFile(targetDir / "godotall.nim", megaImport) + writeFile(targetDir / splitPath(targetDir)[1] & ".nimble", "") + +when isMainModule: + import os + + const usage = """Tool for wrapping Godot API into Nim + + godotapigen [godot binary path] [target directory]""" + + proc main() = + if paramCount() < 2: + echo usage + quit(-1) + let godotBin = paramStr(1) + let targetDir = paramStr(2) + + if not dirExists(targetDir): + echo "The specified directory does not exist" + quit(-1) + if not fileExists(godotBin): + echo "Invalid godot binary path" + quit(-1) + + let jsonFile = targetDir / "api.json" + if fileExists(jsonFile) and + godotBin.getLastModificationTime() <= jsonFile.getLastModificationTime(): + echo "api.json is up to date - doing nothing." + return + + discard execShellCmd( + "\"" & godotBin & "\" --gdnative-generate-json-api \"" & jsonFile & "\"") + if not fileExists(jsonFile): + echo "Failed to generate api.json" + quit(-1) + + genApi(targetDir, jsonFile) + + main() From fb8c42a2cc0f054865fe5152cabe7d24759a9f32 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 18:16:42 +0700 Subject: [PATCH 027/160] Fix circular imports --- godot/core/arrays.nim | 6 +- godot/core/dictionaries.nim | 15 ++-- godot/core/poolarrays.nim | 147 ++++++++++++++++++++++-------------- godot/core/variants.nim | 15 +--- 4 files changed, 106 insertions(+), 77 deletions(-) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index a32690d..b2fc4e9 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -23,7 +23,7 @@ proc newArray*(arr: GodotArray): Array {.inline.} = new(result, arrayFinalizer) result.godotArray = arr -import poolarrays, variants +import poolarrays proc newArray*(pca: PoolColorArray): Array {.inline.} = new(result, arrayFinalizer) @@ -127,10 +127,10 @@ proc len*(self: Array): int {.inline.} = proc sort*(self: var Array) {.inline.} = self.godotArray.sort() -iterator items*(arr: Array): Variant {.inline.} = +iterator items*(arr: Array): Variant = for i in 0.. Date: Mon, 31 Jul 2017 18:44:52 +0700 Subject: [PATCH 028/160] Export exported fields in gdobj --- godot/nim/godotmacros.nim | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 42019e0..964cb1d 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -13,6 +13,7 @@ type hint: string hintTip: string usage: string + isExported: bool MethodDecl = ref object name: string @@ -123,7 +124,8 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = hint: hint, hintTip: hintTip, isNoGodot: isNoGodot, - usage: usage + usage: usage, + isExported: nameNode.isExported() )) proc parseMethod(meth: NimNode): MethodDecl = @@ -375,7 +377,9 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = if not decl.defaultValue.isNil and decl.defaultValue.kind != nnkEmpty: parseError(decl.defaultValue, "Default values are not supported for fields for now.") - recList.add(newIdentDefs(decl.name, decl.typ)) + let name = if not decl.isExported: decl.name + else: postfix(decl.name, "*") + recList.add(newIdentDefs(name, decl.typ)) # 2. {.this: self.} for convenience result.add(newNimNode(nnkPragma).add(newNimNode(nnkExprColonExpr).add( From be02bdfd9c074494590be694245def8c289ab8d8 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 19:00:15 +0700 Subject: [PATCH 029/160] Put internal types in their modules --- godot/core/arrays.nim | 2 +- godot/core/dictionaries.nim | 3 +-- godot/core/rids.nim | 2 +- godot/core/variants.nim | 6 ++---- godot/godotinternal.nim | 4 ++-- godot/internal/godotarrays.nim | 6 +++++- godot/internal/godotdictionaries.nim | 2 +- godot/internal/godotinternaltypes.nim | 8 -------- godot/internal/godotobjects.nim | 4 ++++ godot/internal/godotpoolarrays.nim | 8 +++----- godot/internal/godotvariants.nim | 7 +++++-- godot/nim/godotmacros.nim | 2 +- godot/nim/godotnim.nim | 2 +- 13 files changed, 27 insertions(+), 29 deletions(-) delete mode 100644 godot/internal/godotinternaltypes.nim create mode 100644 godot/internal/godotobjects.nim diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index b2fc4e9..9ec5b68 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,7 +1,7 @@ # Copyright 2017 Xored Software, Inc. import hashes -import internal.godotinternaltypes, internal.godotarrays +import internal.godotarrays type Array* = ref object diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index d25e19f..6be9bf6 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,8 +1,7 @@ # Copyright 2017 Xored Software, Inc. import hashes -import internal.godotinternaltypes, internal.godotstrings, - internal.godotdictionaries, internal.godotvariants +import internal / [godotstrings, godotdictionaries, godotvariants] type Dictionary* = ref object diff --git a/godot/core/rids.nim b/godot/core/rids.nim index b63875c..82a5154 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -1,4 +1,4 @@ -import internal.godotinternaltypes +import internal.godotobjects type RID* {.byref.} = object diff --git a/godot/core/variants.nim b/godot/core/variants.nim index 628adb4..f1efd9e 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -1,9 +1,7 @@ import tables -import internal.godotinternaltypes -import internal.godotvariants -import internal.godotpoolarrays, internal.godotstrings, - internal.godotnodepaths +import internal / [godotobjects, godotvariants, godotpoolarrays, godotstrings, + godotnodepaths] type Variant* = ref object diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index 0ec3959..0fd8cb9 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -1,10 +1,10 @@ # Copyright 2017 Xored Software, Inc. import internal / [ - godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays, + godotobjects, godotarrays, godotnodepaths, godotpoolarrays, godotstrings, godotvariants, godotdictionaries] -export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays, +export godotobjects, godotarrays, godotnodepaths, godotpoolarrays, godotstrings, godotvariants, godotdictionaries const MAX_ARG_COUNT* = 128 diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index c74a9ff..f63f3ce 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -1,7 +1,11 @@ # Copyright (c) 2017 Xored Software, Inc. +type + GodotArray* {.byref.} = object + p: pointer + import hashes -import godotinternaltypes, godotpoolarrays, godotvariants, godotstrings +import godotobjects, godotpoolarrays, godotvariants, godotstrings proc initGodotArray*(dest: var GodotArray) {. importc: "godot_array_new".} diff --git a/godot/internal/godotdictionaries.nim b/godot/internal/godotdictionaries.nim index 715b030..24fee10 100644 --- a/godot/internal/godotdictionaries.nim +++ b/godot/internal/godotdictionaries.nim @@ -4,7 +4,7 @@ type GodotDictionary* {.byref.} = object p: pointer -import godotinternaltypes, godotarrays, godotvariants, godotstrings +import godotarrays, godotvariants, godotstrings proc initGodotDictionary*(dest: var GodotDictionary; src: GodotDictionary) {. importc: "godot_dictionary_new_copy".} diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim deleted file mode 100644 index 8ccbc06..0000000 --- a/godot/internal/godotinternaltypes.nim +++ /dev/null @@ -1,8 +0,0 @@ -# Copyright 2017 Xored Software, Inc. - -type - GodotObject* = object - GodotArray* {.byref.} = object - p: pointer - GodotVariant* {.byref.} = object - data: array[24, byte] \ No newline at end of file diff --git a/godot/internal/godotobjects.nim b/godot/internal/godotobjects.nim new file mode 100644 index 0000000..9286098 --- /dev/null +++ b/godot/internal/godotobjects.nim @@ -0,0 +1,4 @@ +# Copyright 2017 Xored Software, Inc. + +type + GodotObject* = object diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index 50f8656..ab4504c 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -1,10 +1,5 @@ # Copyright (c) 2017 Xored Software, Inc. - -import godotinternaltypes, godotstrings -import core.godotbase, core.colors, - core.vector2, core.vector3 - type GodotPoolByteArray* {.byref.} = object p: pointer @@ -21,6 +16,9 @@ type GodotPoolColorArray* {.byref.} = object p: pointer +import godotstrings, godotarrays +import core / [godotbase, colors, vector2, vector3] + # byte proc initGodotPoolByteArray*(dest: var GodotPoolByteArray) {. diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 13c0f59..56a125d 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -45,8 +45,11 @@ type argument*: cint expected*: VariantType -import godotinternaltypes, godotpoolarrays, godotstrings, godotnodepaths, - godotdictionaries + GodotVariant* {.byref.} = object + data: array[24, byte] + +import godotobjects, godotarrays, godotpoolarrays, + godotstrings, godotnodepaths, godotdictionaries import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes, diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 964cb1d..bebb234 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -1,7 +1,7 @@ # Copyright 2017 Xored Software, Inc. import macros, tables, typetraits -import "../godotinternal.nim", internal.godotvariants +import godotinternal, internal.godotvariants import godotnim, core.variants type diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 450571b..7639c78 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -8,7 +8,7 @@ import core.vector2, core.rect2, core.basis, core.transforms, core.colors, core.nodepaths, core.rids, core.dictionaries, core.arrays, core.poolarrays, core.variants -import "../godotinternal.nim" +import godotinternal ## Definition of NimGodotObject and converters for built-in types. From 31bd5ff4c6fe7fb243198294df649c91dc2f193d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 21:22:25 +0700 Subject: [PATCH 030/160] NimRuntime only works during idle time --- godot/nimruntime.nim | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/godot/nimruntime.nim b/godot/nimruntime.nim index 4429508..8a392b5 100644 --- a/godot/nimruntime.nim +++ b/godot/nimruntime.nim @@ -4,7 +4,13 @@ import asyncdispatch import godot, node gdobj NimRuntime of Node: - method process*(delta: float64) = + method enterTree*() = + discard getTree().connect("idle_frame", self, "idle", newArray()) + + method exitTree*() = + getTree().disconnect("idle_frame", self, "idle") + + proc idle*() {.gdExport.} = if asyncdispatch.hasPendingOperations(): poll(0) GC_step(2000, false, 0) From 0fd0101432c1fed1004f50b035fcf74f75f004a8 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 22:22:40 +0700 Subject: [PATCH 031/160] Rename simple -> stub --- README.md | 2 +- examples/simple/README.md | 12 ------------ examples/{simple => stub}/.gitignore | 0 examples/stub/README.md | 11 +++++++++++ examples/{simple => stub}/nakefile.nim | 0 examples/{simple => stub}/project/default_env.tres | 0 .../project/fonts/Roboto/RobotoRegular.tres | 0 .../project/fonts/Roboto/ttf/LICENSE.txt | 0 .../project/fonts/Roboto/ttf/Roboto-Regular.ttf | Bin examples/{simple => stub}/project/fps_counter.tscn | 0 examples/{simple => stub}/project/icon.png | Bin examples/{simple => stub}/project/icon.png.import | 0 examples/{simple => stub}/project/main.tscn | 0 examples/{simple => stub}/project/nimlib.tres | 0 examples/{simple => stub}/project/project.godot | 2 +- examples/{simple => stub}/project/scene.tscn | 0 .../project/scripts/FPSCounter.gdns | 0 .../{simple => stub}/project/scripts/MainPanel.gdns | 0 .../project/scripts/NimRuntime.gdns | 0 examples/{simple => stub}/src/config.nims | 0 examples/{simple => stub}/src/fpscounter.nim | 0 examples/{simple => stub}/src/mainpanel.nim | 0 examples/{simple => stub}/src/nim.cfg | 2 -- .../{simple/src/simple.nim => stub/src/stub.nim} | 0 .../src/simple.nimble => stub/src/stub.nimble} | 12 ++++++------ 25 files changed, 19 insertions(+), 22 deletions(-) delete mode 100644 examples/simple/README.md rename examples/{simple => stub}/.gitignore (100%) create mode 100644 examples/stub/README.md rename examples/{simple => stub}/nakefile.nim (100%) rename examples/{simple => stub}/project/default_env.tres (100%) rename examples/{simple => stub}/project/fonts/Roboto/RobotoRegular.tres (100%) rename examples/{simple => stub}/project/fonts/Roboto/ttf/LICENSE.txt (100%) rename examples/{simple => stub}/project/fonts/Roboto/ttf/Roboto-Regular.ttf (100%) rename examples/{simple => stub}/project/fps_counter.tscn (100%) rename examples/{simple => stub}/project/icon.png (100%) rename examples/{simple => stub}/project/icon.png.import (100%) rename examples/{simple => stub}/project/main.tscn (100%) rename examples/{simple => stub}/project/nimlib.tres (100%) rename examples/{simple => stub}/project/project.godot (88%) rename examples/{simple => stub}/project/scene.tscn (100%) rename examples/{simple => stub}/project/scripts/FPSCounter.gdns (100%) rename examples/{simple => stub}/project/scripts/MainPanel.gdns (100%) rename examples/{simple => stub}/project/scripts/NimRuntime.gdns (100%) rename examples/{simple => stub}/src/config.nims (100%) rename examples/{simple => stub}/src/fpscounter.nim (100%) rename examples/{simple => stub}/src/mainpanel.nim (100%) rename examples/{simple => stub}/src/nim.cfg (78%) rename examples/{simple/src/simple.nim => stub/src/stub.nim} (100%) rename examples/{simple/src/simple.nimble => stub/src/stub.nimble} (69%) diff --git a/README.md b/README.md index 90a3e1b..6c7907e 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here). -Documentation is coming. You can learn from the [sample project](examples/simple) in the meantime. +Documentation is coming. You can learn from the [project stub](examples/stub) in the meantime. ## Links diff --git a/examples/simple/README.md b/examples/simple/README.md deleted file mode 100644 index 9eb7cb4..0000000 --- a/examples/simple/README.md +++ /dev/null @@ -1,12 +0,0 @@ -Simple project just to demonstrate usage of the library. - -Prerequisites: - -1. Install [nake](https://github.com/fowlmouth/nake): `nimble install nake -n`. -2. Ensure `~/.nimble/bin` is in your PATH. -3. Set `GODOT_BIN` environment varible to point to Godot executable (currently requires Godot fork - see below). -4. Install godot-nim: `nimble install https://github.com/pragmagic/godot-nim.git` (needed for nakefile) - -Run `nake build` in this directory to compile for the current platform. - -**NOTE:** Currently this only works with `kingdom` branch of Godot fork: https://github.com/endragor/godot. However, there are pending PRs to make this work with Godot mainline version. \ No newline at end of file diff --git a/examples/simple/.gitignore b/examples/stub/.gitignore similarity index 100% rename from examples/simple/.gitignore rename to examples/stub/.gitignore diff --git a/examples/stub/README.md b/examples/stub/README.md new file mode 100644 index 0000000..32fcd2d --- /dev/null +++ b/examples/stub/README.md @@ -0,0 +1,11 @@ +Stub project to demonstrate usage of the godot-nim library. + +Prerequisites: + +1. Install [nake](https://github.com/fowlmouth/nake): `nimble install nake -n`. +2. Ensure `~/.nimble/bin` is in your PATH. +3. Set `GODOT_BIN` environment varible to point to Godot executable (requires Godot 3.0 changeset [d28e9c3](https://github.com/godotengine/godot/commit/d28e9c3c0813e729195357dbb9ccd337494bc6d7) or newer). +4. (Windows only) Set `GODOT_LIB` to point to Godot's .lib file. It should be in the `bin` folder after you build Godot. +5. Install godot-nim: `nimble install godot` + +Run `nake build` in any directory within the project to compile for the current platform. diff --git a/examples/simple/nakefile.nim b/examples/stub/nakefile.nim similarity index 100% rename from examples/simple/nakefile.nim rename to examples/stub/nakefile.nim diff --git a/examples/simple/project/default_env.tres b/examples/stub/project/default_env.tres similarity index 100% rename from examples/simple/project/default_env.tres rename to examples/stub/project/default_env.tres diff --git a/examples/simple/project/fonts/Roboto/RobotoRegular.tres b/examples/stub/project/fonts/Roboto/RobotoRegular.tres similarity index 100% rename from examples/simple/project/fonts/Roboto/RobotoRegular.tres rename to examples/stub/project/fonts/Roboto/RobotoRegular.tres diff --git a/examples/simple/project/fonts/Roboto/ttf/LICENSE.txt b/examples/stub/project/fonts/Roboto/ttf/LICENSE.txt similarity index 100% rename from examples/simple/project/fonts/Roboto/ttf/LICENSE.txt rename to examples/stub/project/fonts/Roboto/ttf/LICENSE.txt diff --git a/examples/simple/project/fonts/Roboto/ttf/Roboto-Regular.ttf b/examples/stub/project/fonts/Roboto/ttf/Roboto-Regular.ttf similarity index 100% rename from examples/simple/project/fonts/Roboto/ttf/Roboto-Regular.ttf rename to examples/stub/project/fonts/Roboto/ttf/Roboto-Regular.ttf diff --git a/examples/simple/project/fps_counter.tscn b/examples/stub/project/fps_counter.tscn similarity index 100% rename from examples/simple/project/fps_counter.tscn rename to examples/stub/project/fps_counter.tscn diff --git a/examples/simple/project/icon.png b/examples/stub/project/icon.png similarity index 100% rename from examples/simple/project/icon.png rename to examples/stub/project/icon.png diff --git a/examples/simple/project/icon.png.import b/examples/stub/project/icon.png.import similarity index 100% rename from examples/simple/project/icon.png.import rename to examples/stub/project/icon.png.import diff --git a/examples/simple/project/main.tscn b/examples/stub/project/main.tscn similarity index 100% rename from examples/simple/project/main.tscn rename to examples/stub/project/main.tscn diff --git a/examples/simple/project/nimlib.tres b/examples/stub/project/nimlib.tres similarity index 100% rename from examples/simple/project/nimlib.tres rename to examples/stub/project/nimlib.tres diff --git a/examples/simple/project/project.godot b/examples/stub/project/project.godot similarity index 88% rename from examples/simple/project/project.godot rename to examples/stub/project/project.godot index 009f1e5..658204c 100644 --- a/examples/simple/project/project.godot +++ b/examples/stub/project/project.godot @@ -1,7 +1,7 @@ config_version=3 [application] -config/name="Simple Sample" +config/name="Godot-Nim Stub" run/main_scene="res://main.tscn" config/icon="res://icon.png" diff --git a/examples/simple/project/scene.tscn b/examples/stub/project/scene.tscn similarity index 100% rename from examples/simple/project/scene.tscn rename to examples/stub/project/scene.tscn diff --git a/examples/simple/project/scripts/FPSCounter.gdns b/examples/stub/project/scripts/FPSCounter.gdns similarity index 100% rename from examples/simple/project/scripts/FPSCounter.gdns rename to examples/stub/project/scripts/FPSCounter.gdns diff --git a/examples/simple/project/scripts/MainPanel.gdns b/examples/stub/project/scripts/MainPanel.gdns similarity index 100% rename from examples/simple/project/scripts/MainPanel.gdns rename to examples/stub/project/scripts/MainPanel.gdns diff --git a/examples/simple/project/scripts/NimRuntime.gdns b/examples/stub/project/scripts/NimRuntime.gdns similarity index 100% rename from examples/simple/project/scripts/NimRuntime.gdns rename to examples/stub/project/scripts/NimRuntime.gdns diff --git a/examples/simple/src/config.nims b/examples/stub/src/config.nims similarity index 100% rename from examples/simple/src/config.nims rename to examples/stub/src/config.nims diff --git a/examples/simple/src/fpscounter.nim b/examples/stub/src/fpscounter.nim similarity index 100% rename from examples/simple/src/fpscounter.nim rename to examples/stub/src/fpscounter.nim diff --git a/examples/simple/src/mainpanel.nim b/examples/stub/src/mainpanel.nim similarity index 100% rename from examples/simple/src/mainpanel.nim rename to examples/stub/src/mainpanel.nim diff --git a/examples/simple/src/nim.cfg b/examples/stub/src/nim.cfg similarity index 78% rename from examples/simple/src/nim.cfg rename to examples/stub/src/nim.cfg index a64088d..66b6618 100644 --- a/examples/simple/src/nim.cfg +++ b/examples/stub/src/nim.cfg @@ -1,8 +1,6 @@ --path:"$projectdir" --path:"$projectdir/../godotapi" ---experimental --app:lib ---stackTrace:on -d:useRealtimeGc --noMain --warning[LockLevel]:off \ No newline at end of file diff --git a/examples/simple/src/simple.nim b/examples/stub/src/stub.nim similarity index 100% rename from examples/simple/src/simple.nim rename to examples/stub/src/stub.nim diff --git a/examples/simple/src/simple.nimble b/examples/stub/src/stub.nimble similarity index 69% rename from examples/simple/src/simple.nimble rename to examples/stub/src/stub.nimble index 22c3f19..d9b81e3 100644 --- a/examples/simple/src/simple.nimble +++ b/examples/stub/src/stub.nimble @@ -1,16 +1,16 @@ version = "0.1.0" author = "Xored Software, Inc." -description = "Simple Sample" +description = "Godot-Nim Project Stub" license = "MIT" -bin = @["simple"] +bin = @["stub"] -requires "https://github.com/pragmagic/godot-nim.git >= 0.3.0 & < 0.4.0" +requires "godot >= 0.3.0 & < 0.4.0" task make, "build": - const archPostfix = when sizeof(int) == 8: "_64" else: "_32" + const bitsPostfix = when sizeof(int) == 8: "_64" else: "_32" const libFile = when defined(windows): - "nim" & archPostfix & ".dll" + "nim" & bitsPostfix & ".dll" elif defined(ios): "nim_ios.dylib" elif defined(macosx): @@ -18,7 +18,7 @@ task make, "build": elif defined(android): "nim_android.so" elif defined(linux): - "nim_linux" & archPostfix & ".so" + "nim_linux" & bitsPostfix & ".so" else: nil if libFile.isNil: raise newException(OSError, "Unsupported platform") From 692fbe892b963b842d215031814c428429264ab5 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 1 Aug 2017 18:25:24 +0700 Subject: [PATCH 032/160] Support tool specifier --- godot/nim/godotmacros.nim | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index bebb234..97d21b0 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -28,6 +28,7 @@ type parentName: string fields: seq[VarDecl] methods: seq[MethodDecl] + isTool: bool ParseError = object of Exception @@ -161,6 +162,18 @@ proc parseType(definition, callSite: NimNode): ObjectDecl = methods: newSeq[MethodDecl]() ) (result.name, result.parentName) = extractNames(definition) + + var isTool = false + for i in 2..(callSite.len - 2): + let option = callSite[i] + if option.kind != nnkIdent: + parseError(option, "type specifier expected") + if option.ident == !"tool": + isTool = true + else: + parseError(option, "valid type specifier expected") + result.isTool = isTool + if result.parentName.isNil: result.parentName = "Object" for statement in body: case statement.kind: @@ -281,7 +294,7 @@ proc refcountDecremented*(obj: NimGodotObject): bool = GC_unref(obj) template registerGodotClass(classNameIdent, classNameLit, isRef, - baseNameLit, createFuncIdent) = + baseNameLit, createFuncIdent; isTool: bool) = proc createFuncIdent(obj: ptr GodotObject, methData: pointer): pointer {.noconv.} = let nimObj = new(classNameIdent) @@ -297,8 +310,12 @@ template registerGodotClass(classNameIdent, classNameLit, isRef, destroyFunc: when isRef: nimDestroyRefFunc else: nimDestroyFunc ) registerClass(classNameIdent, classNameLit, false) - godotScriptRegisterClass(getNativeLibHandle(), classNameLit, baseNameLit, - createFuncObj, destroyFuncObj) + when isTool: + godotScriptRegisterToolClass(getNativeLibHandle(), classNameLit, baseNameLit, + createFuncObj, destroyFuncObj) + else: + godotScriptRegisterClass(getNativeLibHandle(), classNameLit, baseNameLit, + createFuncObj, destroyFuncObj) template registerGodotField(classNameLit, classNameIdent, propNameLit, propNameIdent, propTypeLit, propTypeIdent, @@ -412,7 +429,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = else: obj.parentName in refClasses result.add(getAst( registerGodotClass(classNameIdent, classNameLit, isRef, parentName, - genSym(nskProc, "createFunc")))) + genSym(nskProc, "createFunc"), obj.isTool))) # 5. Register fields (properties) for field in obj.fields: @@ -502,6 +519,13 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = noArgs, genSym(nskProc, "refcount_decremented"), ident("true")))) -macro gdobj*(definition: untyped, body: untyped): typed = +{.push warning[Deprecated]: off.} +# immediate macros are deprecated, but `untyped` doesnt make it immediate, +# as the warning and the documentation claim. + +macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = let typeDef = parseType(definition, callsite()) result = genType(typeDef) + +{.push warning[Deprecated]: on.} + From a91fe1f713b6d2d264951d77520caec31fd00f74 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 1 Aug 2017 20:50:10 +0700 Subject: [PATCH 033/160] Temporary solution for multilevel calls --- godot/nim/godotmacros.nim | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 97d21b0..4e33bd6 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -191,7 +191,7 @@ proc parseType(definition, callSite: NimNode): ObjectDecl = macro invokeVarArgs(procIdent, objIdent; minArgs, maxArgs: static[int], numArgsIdent, argSeqIdent; argTypes: seq[NimNode], - hasReturnValue: static[bool]): typed = + hasReturnValue, isStaticCall: static[bool]): typed = ## Produces statement in form: ## ## .. code-block:: nim @@ -233,7 +233,7 @@ macro invokeVarArgs(procIdent, objIdent; for i in minArgs..maxArgs: let branch = newNimNode(nnkOfBranch).add(newIntLitNode(i)) let branchBody = newStmtList() - let invocation = newNimNode(nnkCall) + var invocation = newNimNode(nnkCall) invocation.add(procIdent) invocation.add(objIdent) # self for idx in 0.. Date: Tue, 1 Aug 2017 20:52:56 +0700 Subject: [PATCH 034/160] Fix GodotVariant size for 32-bit platforms --- godot/internal/godotvariants.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 56a125d..39d36eb 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -46,7 +46,7 @@ type expected*: VariantType GodotVariant* {.byref.} = object - data: array[24, byte] + data: array[16 + sizeof(int), byte] import godotobjects, godotarrays, godotpoolarrays, godotstrings, godotnodepaths, godotdictionaries From 0af5eb3b7f0bebd5154cbd412bcae7876bb1ca2e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 1 Aug 2017 20:59:34 +0700 Subject: [PATCH 035/160] Print godotapigen progress (closes #3) --- godot/godotapigen.nim | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 7549624..42b3ea3 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -780,6 +780,8 @@ proc genApi*(targetDir: string, apiJsonFile: string) = isSingleton: obj["singleton"].bval ) for typ in types.values(): + let moduleName = typeNameToModuleName(typ.name) + echo "Generating ", moduleName, ".nim..." let tree = newNode(nkStmtList) let importStmt = newNode(nkImportStmt) importStmt.add(ident("godot")) @@ -829,7 +831,6 @@ proc genApi*(targetDir: string, apiJsonFile: string) = makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = true) - let moduleName = typeNameToModuleName(typ.name) renderModule(tree, targetDir / moduleName & ".nim") megaImport.add("import \"" & moduleName & "\"\n") From 294c057ff9f9c4a28ced9773ce883b95b05d3622 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 1 Aug 2017 21:06:20 +0700 Subject: [PATCH 036/160] Suppress false warning --- godot/nim/godotmacros.nim | 2 ++ 1 file changed, 2 insertions(+) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 4e33bd6..fd7def7 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -355,12 +355,14 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, let getFunc = GodotPropertyGetFunc( getFunc: getFuncIdent ) + {.push warning[ProveInit]: off.} # false warning, Nim bug var attr = GodotPropertyAttributes( typ: ord(godotVariantType(propTypeIdent)), hintString: hintTipLit.toGodotString(), hint: GodotPropertyHint.hintIdent, usage: GodotPropertyUsageFlags.usageIdent ) + {.push warning[ProveInit]: on.} when hasDefaultValue: attr.defaultValue = (defaultValueNode).toGodot() godotScriptRegisterProperty(getNativeLibHandle(), classNameLit, propNameLit, From ec707ea7767cbb0fd583209b029b1ad16fc0e91c Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 1 Aug 2017 22:50:26 +0700 Subject: [PATCH 037/160] Stub moved to separate repo --- README.md | 2 +- examples/stub/.gitignore | 5 - examples/stub/README.md | 11 - examples/stub/nakefile.nim | 43 ---- examples/stub/project/default_env.tres | 99 --------- .../project/fonts/Roboto/RobotoRegular.tres | 5 - .../stub/project/fonts/Roboto/ttf/LICENSE.txt | 202 ------------------ .../fonts/Roboto/ttf/Roboto-Regular.ttf | Bin 171676 -> 0 bytes examples/stub/project/fps_counter.tscn | 34 --- examples/stub/project/icon.png | Bin 3406 -> 0 bytes examples/stub/project/icon.png.import | 23 -- examples/stub/project/main.tscn | 50 ----- examples/stub/project/nimlib.tres | 12 -- examples/stub/project/project.godot | 14 -- examples/stub/project/scene.tscn | 48 ----- examples/stub/project/scripts/FPSCounter.gdns | 9 - examples/stub/project/scripts/MainPanel.gdns | 9 - examples/stub/project/scripts/NimRuntime.gdns | 9 - examples/stub/src/config.nims | 43 ---- examples/stub/src/fpscounter.nim | 17 -- examples/stub/src/mainpanel.nim | 18 -- examples/stub/src/nim.cfg | 6 - examples/stub/src/stub.nim | 12 -- examples/stub/src/stub.nimble | 34 --- 24 files changed, 1 insertion(+), 704 deletions(-) delete mode 100644 examples/stub/.gitignore delete mode 100644 examples/stub/README.md delete mode 100644 examples/stub/nakefile.nim delete mode 100644 examples/stub/project/default_env.tres delete mode 100644 examples/stub/project/fonts/Roboto/RobotoRegular.tres delete mode 100755 examples/stub/project/fonts/Roboto/ttf/LICENSE.txt delete mode 100755 examples/stub/project/fonts/Roboto/ttf/Roboto-Regular.ttf delete mode 100644 examples/stub/project/fps_counter.tscn delete mode 100644 examples/stub/project/icon.png delete mode 100644 examples/stub/project/icon.png.import delete mode 100644 examples/stub/project/main.tscn delete mode 100644 examples/stub/project/nimlib.tres delete mode 100644 examples/stub/project/project.godot delete mode 100644 examples/stub/project/scene.tscn delete mode 100644 examples/stub/project/scripts/FPSCounter.gdns delete mode 100644 examples/stub/project/scripts/MainPanel.gdns delete mode 100644 examples/stub/project/scripts/NimRuntime.gdns delete mode 100644 examples/stub/src/config.nims delete mode 100644 examples/stub/src/fpscounter.nim delete mode 100644 examples/stub/src/mainpanel.nim delete mode 100644 examples/stub/src/nim.cfg delete mode 100644 examples/stub/src/stub.nim delete mode 100644 examples/stub/src/stub.nimble diff --git a/README.md b/README.md index 6c7907e..7512cec 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here). -Documentation is coming. You can learn from the [project stub](examples/stub) in the meantime. +Documentation is coming. You can learn from the [project stub](https://github.com/pragmagic/godot-nim-stub) in the meantime. ## Links diff --git a/examples/stub/.gitignore b/examples/stub/.gitignore deleted file mode 100644 index 7bb79bb..0000000 --- a/examples/stub/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -/project/.import -/project/_dlls -/nakefile -/godotapi -nimcache diff --git a/examples/stub/README.md b/examples/stub/README.md deleted file mode 100644 index 32fcd2d..0000000 --- a/examples/stub/README.md +++ /dev/null @@ -1,11 +0,0 @@ -Stub project to demonstrate usage of the godot-nim library. - -Prerequisites: - -1. Install [nake](https://github.com/fowlmouth/nake): `nimble install nake -n`. -2. Ensure `~/.nimble/bin` is in your PATH. -3. Set `GODOT_BIN` environment varible to point to Godot executable (requires Godot 3.0 changeset [d28e9c3](https://github.com/godotengine/godot/commit/d28e9c3c0813e729195357dbb9ccd337494bc6d7) or newer). -4. (Windows only) Set `GODOT_LIB` to point to Godot's .lib file. It should be in the `bin` folder after you build Godot. -5. Install godot-nim: `nimble install godot` - -Run `nake build` in any directory within the project to compile for the current platform. diff --git a/examples/stub/nakefile.nim b/examples/stub/nakefile.nim deleted file mode 100644 index 2d3075c..0000000 --- a/examples/stub/nakefile.nim +++ /dev/null @@ -1,43 +0,0 @@ -# Copyright 2017 Xored Software, Inc. - -import nake -import os, ospaths, times -import godotapigen - -proc cmdParams(): string = - let params = commandLineParams() - assert(params.len > 0) - result = params[1.. jsonFile.getLastModificationTime(): - direShell(godotBin, "--gdnative-generate-json-api", jsonFile) - if not fileExists(jsonFile): - echo "Failed to generate api.json" - quit(-1) - - genApi(targetDir, jsonFile) - -task "build", "Builds the client for the current platform": - genGodotApi() - withDir "src": - direShell("nimble", "make") - -task "clean", "Remove files produced by build": - removeDir("nimcache") - removeDir("src"/"nimcache") - removeDir("godotapi") - removeDir("project"/"_dlls") - removeFile("nakefile") diff --git a/examples/stub/project/default_env.tres b/examples/stub/project/default_env.tres deleted file mode 100644 index a22ed59..0000000 --- a/examples/stub/project/default_env.tres +++ /dev/null @@ -1,99 +0,0 @@ -[gd_resource type="Environment" load_steps=2 format=2] - -[sub_resource type="ProceduralSky" id=1] - -radiance_size = 4 -sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 ) -sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 ) -sky_curve = 0.25 -sky_energy = 1.0 -ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 ) -ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 ) -ground_curve = 0.01 -ground_energy = 1.0 -sun_color = Color( 1, 1, 1, 1 ) -sun_latitude = 35.0 -sun_longitude = 0.0 -sun_angle_min = 1.0 -sun_angle_max = 100.0 -sun_curve = 0.05 -sun_energy = 16.0 -texture_size = 2 - -[resource] - -background_mode = 2 -background_sky = SubResource( 1 ) -background_sky_scale = 1.0 -background_color = Color( 0, 0, 0, 1 ) -background_energy = 1.0 -background_canvas_max_layer = 0 -ambient_light_color = Color( 0, 0, 0, 1 ) -ambient_light_energy = 1.0 -ambient_light_sky_contribution = 0.0 -fog_enabled = false -fog_color = Color( 0.5, 0.6, 0.7, 1 ) -fog_sun_color = Color( 1, 0.9, 0.7, 1 ) -fog_sun_amount = 0.0 -fog_depth_enabled = true -fog_depth_begin = 10.0 -fog_depth_curve = 1.0 -fog_transmit_enabled = false -fog_transmit_curve = 1.0 -fog_height_enabled = false -fog_height_min = 0.0 -fog_height_max = 100.0 -fog_height_curve = 1.0 -tonemap_mode = 0 -tonemap_exposure = 1.0 -tonemap_white = 1.0 -auto_exposure_enabled = false -auto_exposure_scale = 0.4 -auto_exposure_min_luma = 0.05 -auto_exposure_max_luma = 8.0 -auto_exposure_speed = 0.5 -ss_reflections_enabled = false -ss_reflections_max_steps = 64 -ss_reflections_fade_in = 0.15 -ss_reflections_fade_out = 2.0 -ss_reflections_depth_tolerance = 0.2 -ss_reflections_roughness = true -ssao_enabled = false -ssao_radius = 1.0 -ssao_intensity = 1.0 -ssao_radius2 = 0.0 -ssao_intensity2 = 1.0 -ssao_bias = 0.01 -ssao_light_affect = 0.0 -ssao_color = Color( 0, 0, 0, 1 ) -ssao_blur = true -dof_blur_far_enabled = false -dof_blur_far_distance = 10.0 -dof_blur_far_transition = 5.0 -dof_blur_far_amount = 0.1 -dof_blur_far_quality = 1 -dof_blur_near_enabled = false -dof_blur_near_distance = 2.0 -dof_blur_near_transition = 1.0 -dof_blur_near_amount = 0.1 -dof_blur_near_quality = 1 -glow_enabled = false -glow_levels/1 = false -glow_levels/2 = false -glow_levels/3 = true -glow_levels/4 = false -glow_levels/5 = true -glow_levels/6 = false -glow_levels/7 = false -glow_intensity = 0.8 -glow_strength = 1.0 -glow_bloom = 0.0 -glow_blend_mode = 2 -glow_hdr_threshold = 1.0 -glow_hdr_scale = 2.0 -glow_bicubic_upscale = false -adjustment_enabled = false -adjustment_brightness = 1.0 -adjustment_contrast = 1.0 -adjustment_saturation = 1.0 - diff --git a/examples/stub/project/fonts/Roboto/RobotoRegular.tres b/examples/stub/project/fonts/Roboto/RobotoRegular.tres deleted file mode 100644 index a1126e5..0000000 --- a/examples/stub/project/fonts/Roboto/RobotoRegular.tres +++ /dev/null @@ -1,5 +0,0 @@ -[gd_resource type="DynamicFontData" format=2] - -[resource] - -font_path = "res://fonts/Roboto/ttf/Roboto-Regular.ttf" diff --git a/examples/stub/project/fonts/Roboto/ttf/LICENSE.txt b/examples/stub/project/fonts/Roboto/ttf/LICENSE.txt deleted file mode 100755 index 75b5248..0000000 --- a/examples/stub/project/fonts/Roboto/ttf/LICENSE.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/examples/stub/project/fonts/Roboto/ttf/Roboto-Regular.ttf b/examples/stub/project/fonts/Roboto/ttf/Roboto-Regular.ttf deleted file mode 100755 index 2c97eeadffe1a34bd67d3ff1c3887fd53e22c2ca..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 171676 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 ZcAgz$Pp~K2ZnnEU$(~HkLK9l*e*jr~ZsGs{ diff --git a/examples/stub/project/fps_counter.tscn b/examples/stub/project/fps_counter.tscn deleted file mode 100644 index 67fc001..0000000 --- a/examples/stub/project/fps_counter.tscn +++ /dev/null @@ -1,34 +0,0 @@ -[gd_scene load_steps=4 format=2] - -[ext_resource path="res://fonts/Roboto/RobotoRegular.tres" type="DynamicFontData" id=1] -[ext_resource path="res://scripts/FPSCounter.gdns" type="Script" id=2] - -[sub_resource type="DynamicFont" id=1] - -size = 40 -use_mipmaps = false -use_filter = false -font_data = ExtResource( 1 ) -_sections_unfolded = [ "Extra Spacing", "Font", "Settings" ] - -[node name="Label" type="Label"] - -anchor_left = 1 -anchor_right = 1 -margin_top = 10.0 -margin_right = 10.0 -grow_horizontal = 0 -rect_pivot_offset = Vector2( 0, 0 ) -rect_clip_content = false -mouse_filter = 2 -size_flags_horizontal = 1 -size_flags_vertical = 4 -custom_fonts/font = SubResource( 1 ) -text = "FPS: 9000" -percent_visible = 1.0 -lines_skipped = 0 -max_lines_visible = -1 -script = ExtResource( 2 ) -_sections_unfolded = [ "Anchor", "Grow Direction", "Margin", "custom_colors", "custom_fonts" ] - - diff --git a/examples/stub/project/icon.png b/examples/stub/project/icon.png deleted file mode 100644 index 21a097a7fcde1bd609bc1e258b59242a6a4bf7a7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3406 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 diff --git a/examples/stub/project/icon.png.import b/examples/stub/project/icon.png.import deleted file mode 100644 index 627820b..0000000 --- a/examples/stub/project/icon.png.import +++ /dev/null @@ -1,23 +0,0 @@ -[remap] - -importer="texture" -type="StreamTexture" -path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" - -[params] - -compress/mode=0 -compress/lossy_quality=0.7 -compress/hdr_mode=0 -compress/normal_map=0 -flags/repeat=0 -flags/filter=true -flags/mipmaps=false -flags/anisotropic=false -flags/srgb=2 -process/fix_alpha_border=true -process/premult_alpha=false -process/HDR_as_SRGB=false -stream=false -size_limit=0 -detect_3d=true diff --git a/examples/stub/project/main.tscn b/examples/stub/project/main.tscn deleted file mode 100644 index 7e4e390..0000000 --- a/examples/stub/project/main.tscn +++ /dev/null @@ -1,50 +0,0 @@ -[gd_scene load_steps=5 format=2] - -[ext_resource path="res://scripts/MainPanel.gdns" type="Script" id=1] -[ext_resource path="res://fonts/Roboto/RobotoRegular.tres" type="DynamicFontData" id=2] -[ext_resource path="res://fps_counter.tscn" type="PackedScene" id=3] - -[sub_resource type="DynamicFont" id=1] - -size = 80 -use_mipmaps = false -use_filter = false -font_data = ExtResource( 2 ) -_sections_unfolded = [ "Font", "Settings" ] - -[node name="Panel" type="Panel"] - -anchor_right = 1 -anchor_bottom = 1 -rect_pivot_offset = Vector2( 0, 0 ) -rect_clip_content = false -mouse_filter = 0 -size_flags_horizontal = 1 -size_flags_vertical = 1 -script = ExtResource( 1 ) -_sections_unfolded = [ "Anchor", "Margin" ] - -[node name="Label" type="Label" parent="."] - -anchor_right = 1 -anchor_bottom = 1 -rect_pivot_offset = Vector2( 0, 0 ) -rect_clip_content = false -mouse_filter = 2 -size_flags_horizontal = 1 -size_flags_vertical = 4 -custom_fonts/font = SubResource( 1 ) -text = "Click me to load scene" -align = 1 -valign = 1 -percent_visible = 1.0 -lines_skipped = 0 -max_lines_visible = -1 -_sections_unfolded = [ "Anchor", "Margin", "custom_fonts" ] - -[node name="FPS" parent="." instance=ExtResource( 3 )] - -margin_left = 189.0 -margin_bottom = 58.0 - - diff --git a/examples/stub/project/nimlib.tres b/examples/stub/project/nimlib.tres deleted file mode 100644 index f95a4f3..0000000 --- a/examples/stub/project/nimlib.tres +++ /dev/null @@ -1,12 +0,0 @@ -[gd_resource type="GDNativeLibrary" format=2] - -[resource] - -platform/X11_32bit = "res://_dlls/nim_linux_32.so" -platform/X11_64bit = "res://_dlls/nim_linux_64.so" -platform/Windows_32bit = "res://_dlls/nim_32.dll" -platform/Windows_64bit = "res://_dlls/nim_64.dll" -platform/OSX = "res://_dlls/nim_mac.dylib" -platform/Android = "res://_dlls/nim_android.so" -platform/iOS = "res://_dlls/nim_ios.dylib" -platform/WebAssembly = "" diff --git a/examples/stub/project/project.godot b/examples/stub/project/project.godot deleted file mode 100644 index 658204c..0000000 --- a/examples/stub/project/project.godot +++ /dev/null @@ -1,14 +0,0 @@ -config_version=3 -[application] - -config/name="Godot-Nim Stub" -run/main_scene="res://main.tscn" -config/icon="res://icon.png" - -[autoload] - -NimRuntime="*res://scripts/NimRuntime.gdns" - -[rendering] - -environment/default_environment="res://default_env.tres" diff --git a/examples/stub/project/scene.tscn b/examples/stub/project/scene.tscn deleted file mode 100644 index 07b4429..0000000 --- a/examples/stub/project/scene.tscn +++ /dev/null @@ -1,48 +0,0 @@ -[gd_scene load_steps=3 format=2] - -[ext_resource path="res://fps_counter.tscn" type="PackedScene" id=1] - -[sub_resource type="CapsuleMesh" id=1] - -radius = 1.0 -mid_height = 1.0 -radial_segments = 64 -rings = 8 - -[node name="Node" type="Node"] - -[node name="MeshInstance" type="MeshInstance" parent="."] - -layers = 1 -material_override = null -cast_shadow = 1 -extra_cull_margin = 0.0 -visible_in_all_rooms = false -use_in_baked_light = false -lod_min_distance = 0.0 -lod_min_hysteresis = 0.0 -lod_max_distance = 0.0 -lod_max_hysteresis = 0.0 -mesh = SubResource( 1 ) -skeleton = NodePath("..") -material/0 = null -_sections_unfolded = [ "Geometry", "material" ] - -[node name="Label" parent="." instance=ExtResource( 1 )] - -[node name="Camera" type="Camera" parent="."] - -transform = Transform( 0.930689, 0.16529, -0.326338, 0, 0.892097, 0.451845, 0.365811, -0.420527, 0.830265, -0.972205, 1.19673, 2.59579 ) -projection = 0 -fov = 65.0 -near = 0.1 -far = 100.0 -keep_aspect = 1 -current = true -cull_mask = 1048575 -environment = null -h_offset = 0.0 -v_offset = 0.0 -doppler/tracking = 0 - - diff --git a/examples/stub/project/scripts/FPSCounter.gdns b/examples/stub/project/scripts/FPSCounter.gdns deleted file mode 100644 index bae69db..0000000 --- a/examples/stub/project/scripts/FPSCounter.gdns +++ /dev/null @@ -1,9 +0,0 @@ -[gd_resource type="NativeScript" load_steps=2 format=2] - -[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1] - -[resource] - -resource_name = "FPSCounter" -library = ExtResource( 1 ) -class_name = "FPSCounter" \ No newline at end of file diff --git a/examples/stub/project/scripts/MainPanel.gdns b/examples/stub/project/scripts/MainPanel.gdns deleted file mode 100644 index 4458a47..0000000 --- a/examples/stub/project/scripts/MainPanel.gdns +++ /dev/null @@ -1,9 +0,0 @@ -[gd_resource type="NativeScript" load_steps=2 format=2] - -[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1] - -[resource] - -resource_name = "MainPanel" -library = ExtResource( 1 ) -class_name = "MainPanel" \ No newline at end of file diff --git a/examples/stub/project/scripts/NimRuntime.gdns b/examples/stub/project/scripts/NimRuntime.gdns deleted file mode 100644 index 34656e9..0000000 --- a/examples/stub/project/scripts/NimRuntime.gdns +++ /dev/null @@ -1,9 +0,0 @@ -[gd_resource type="NativeScript" load_steps=2 format=2] - -[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1] - -[resource] - -resource_name = "NimRuntime" -library = ExtResource( 1 ) -class_name = "NimRuntime" \ No newline at end of file diff --git a/examples/stub/src/config.nims b/examples/stub/src/config.nims deleted file mode 100644 index 1f1cdf3..0000000 --- a/examples/stub/src/config.nims +++ /dev/null @@ -1,43 +0,0 @@ -import ospaths - -switch("nimcache", "nimcache"/hostOS/hostCPU) - -when defined(macosx): - switch("passL", "-framework Cocoa -Wl,-undefined,dynamic_lookup") -elif defined(android): - let ndk = getEnv("ANDROID_NDK_ROOT") - let toolchain = getEnv("ANDROID_TOOLCHAIN") - - if ndk.len == 0: - raise newException(OSError, - "ANDROID_NDK_ROOT environment variable is necessary for android build") - if toolchain.len == 0: - raise newException(OSError, - "ANDROID_TOOLCHAIN environment variable is necessary for android build") - - const level = $16 # change this to the necessary API level - const arch = "arm" - let sysroot = "--sysroot=\"" & ndk & "/platforms/android-" & level & "/arch-" & arch & "/\"" - switch("passL", sysroot) - switch("passC", sysroot) - - switch("cc", "clang") - switch("arm.linux.clang.path", toolchain / "bin") - switch("arm.linux.clang.exe", arch & "-linux-androideabi-clang") - switch("arm.linux.clang.compilerexe", arch & "-linux-androideabi-clang") - switch("arm.linux.clang.linkerexe", arch & "-linux-androideabi-clang") -elif defined(windows): - assert(sizeof(int) == 8) - switch("cc", "vcc") - let godotLib = getEnv("GODOT_LIB") - if godotLib.len == 0: - raise newException(OSError, - "GODOT_LIB must be specified and point to the .lib file") - switch("clib", godotLib.changeFileExt("")) -elif defined(linux): - switch("passC", "-fPIC") -else: - raise newException(OSError, "Unsupported platform: " & hostOS) - -when not defined(release): - switch("debugger", "native") diff --git a/examples/stub/src/fpscounter.nim b/examples/stub/src/fpscounter.nim deleted file mode 100644 index 01be84f..0000000 --- a/examples/stub/src/fpscounter.nim +++ /dev/null @@ -1,17 +0,0 @@ -# Copyright 2017 Xored Software, Inc. - -import strutils -import godot -import engine, label - -gdobj FPSCounter of Label: - var lastFPS: float32 - - method ready*() = - setProcess(true) - - method process*(delta: float64) = - let fps = getFramesPerSecond() - if int(fps * 10) != int(lastFPS * 10): - lastFPS = fps - self.text = "FPS: " & formatFloat(fps, ffDecimal, 1) diff --git a/examples/stub/src/mainpanel.nim b/examples/stub/src/mainpanel.nim deleted file mode 100644 index 8f6c16e..0000000 --- a/examples/stub/src/mainpanel.nim +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2017 Xored Software, Inc. - -import godot -import scene_tree, resource_loader, packed_scene, panel, global_constants, - input_event_mouse_button - -gdobj MainPanel of Panel: - method ready*() = - setProcessInput(true) - - method input*(event: InputEvent) = - if event of InputEventMouseButton: - let ev = event as InputEventMouseButton - if ev.buttonIndex == BUTTON_LEFT: - getTree().setInputAsHandled() - let scene = load("res://scene.tscn") as PackedScene - getTree().getRoot().addChild(scene.instance()) - queueFree() diff --git a/examples/stub/src/nim.cfg b/examples/stub/src/nim.cfg deleted file mode 100644 index 66b6618..0000000 --- a/examples/stub/src/nim.cfg +++ /dev/null @@ -1,6 +0,0 @@ ---path:"$projectdir" ---path:"$projectdir/../godotapi" ---app:lib --d:useRealtimeGc ---noMain ---warning[LockLevel]:off \ No newline at end of file diff --git a/examples/stub/src/stub.nim b/examples/stub/src/stub.nim deleted file mode 100644 index 5e725b8..0000000 --- a/examples/stub/src/stub.nim +++ /dev/null @@ -1,12 +0,0 @@ -# Copyright 2017 Xored Software, Inc. - -## Import independent scene objects here -## (no need to import everything, just independent roots) - -when not defined(release): - import segfaults # converts segfaults into NilAccessError - -import nimruntime - -import fpscounter -import mainpanel diff --git a/examples/stub/src/stub.nimble b/examples/stub/src/stub.nimble deleted file mode 100644 index d9b81e3..0000000 --- a/examples/stub/src/stub.nimble +++ /dev/null @@ -1,34 +0,0 @@ -version = "0.1.0" -author = "Xored Software, Inc." -description = "Godot-Nim Project Stub" -license = "MIT" -bin = @["stub"] - -requires "godot >= 0.3.0 & < 0.4.0" - -task make, "build": - const bitsPostfix = when sizeof(int) == 8: "_64" else: "_32" - const libFile = - when defined(windows): - "nim" & bitsPostfix & ".dll" - elif defined(ios): - "nim_ios.dylib" - elif defined(macosx): - "nim_mac.dylib" - elif defined(android): - "nim_android.so" - elif defined(linux): - "nim_linux" & bitsPostfix & ".so" - else: nil - if libFile.isNil: - raise newException(OSError, "Unsupported platform") - - exec "nimble build -y" - const dir = "../project/_dlls/" - const target = dir & libFile - mkDir(dir) - when defined(windows): - rmFile(target) - mvFile(bin[0] & ".exe", target) - else: - mvFile(bin[0], target) From 988b9e1f11164c92118960283ee6eff9ccd0d43e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 31 Jul 2017 18:52:07 +0700 Subject: [PATCH 038/160] Documentation & Travis & Refactoring --- .gitignore | 6 + .travis.yml | 54 ++++++++ docs/docbuild.nim | 159 +++++++++++++++++++++ docs/docpublish.nim | 94 +++++++++++++ docs/godotapi.rst | 12 ++ docs/index.rst | 198 +++++++++++++++++++++++++++ docs/nim.cfg | 1 + godot.nimble | 2 +- godot/apigen/apigen.nim | 3 - godot/core/dictionaries.nim | 3 +- godot/core/nim.cfg | 1 + godot/core/rids.nim | 2 +- godot/core/variants.nim | 4 +- godot/godot.nim | 12 +- godot/godotapigen.nim | 24 +++- godot/godotinternal.nim | 11 +- godot/internal/godotarrays.nim | 2 +- godot/internal/godotdictionaries.nim | 2 +- godot/internal/godotnodepaths.nim | 2 +- godot/internal/godotpoolarrays.nim | 16 +-- godot/internal/godotstrings.nim | 2 +- godot/internal/godotvariants.nim | 2 +- godot/internal/nim.cfg | 1 + godot/nim/godotmacros.nim | 120 ++++++++++++---- godot/nim/godotnim.nim | 156 ++++++++++++--------- godot/nim/nim.cfg | 1 + godot/nimdoc.cfg | 5 + 27 files changed, 772 insertions(+), 123 deletions(-) create mode 100644 .travis.yml create mode 100644 docs/docbuild.nim create mode 100644 docs/docpublish.nim create mode 100644 docs/godotapi.rst create mode 100644 docs/index.rst create mode 100644 docs/nim.cfg delete mode 100644 godot/apigen/apigen.nim create mode 100644 godot/core/nim.cfg create mode 100644 godot/internal/nim.cfg create mode 100644 godot/nim/nim.cfg create mode 100644 godot/nimdoc.cfg diff --git a/.gitignore b/.gitignore index e45da94..e06f7ed 100644 --- a/.gitignore +++ b/.gitignore @@ -5,4 +5,10 @@ nimcache/ /godot/godotapigen /godot/godotapigen.exe +/docgen +/docs/docbuild +/docs/docbuild.exe +/docs/docpublish +/docs/docpublish.exe + .DS_Store \ No newline at end of file diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..0d0ec4d --- /dev/null +++ b/.travis.yml @@ -0,0 +1,54 @@ +sudo: false +language: c +os: + - osx +compiler: clang +env: + global: + - secure: o+IZkRS6J7bGYkiilm10KDeCTDIVHszZ9dPvb93cdUKX/9hFVRiUjDOvNXqBdyOv43JIAsRTppym4B2pfcp9cwLoVBJNW70GKhp6ChLZm3wFdabScWKemuG2YtAUyGiSmxbVmUZ4baltnADyGFHuYWgHLjx6AKO26SqrXRLJ0I1IzGNKKNIfoyZzm7qdFDGJRnSC7L+y1pOITK7dpy60D1vat4FhOLaz2K7L8T8tZYZFK7yyxKduFUlY3cy4z3TpjxMa9/ksCiPiuPDN5xOrVIw0AtgZ2gYodZJUEnfaRzFkgcZ4OJuTAMNMalu52mVAVAoDt4yc7BnbtfsYJzfIjTeLjjWKWz8mqqp/HpxcfVnmPKxV5zeN8UhbosT8vNjwretWbQcFndzt0ohK7E8uMsnDGER7sGPEhCZCttkId96gi7Ro1awPIKCqLaMqB43Bwo48nnW0oQgrfWe1ZKtREXWI4F1F2GMbU8Jsvv0N5GnPGd4RDieBH5KIkJXcttAwRk8AUQ4U5PVkQ/OK9xm9BH2tB0vrjZ4FZWnFPapKVcPUYw9deyyXOXwSMmDpuwkJIjqi3tRyBWJG9+tUlAJw8zyFkCPeN9kzyVH/PhbacwBMdSxew24VLAWWCUhQHCP+fcjpKio8uDUFQN3javIRV4N3mHJ9v0VAF7Ixzh8AviQ= + +addons: + apt: + sources: + - ubuntu-toolchain-r-test + - llvm-toolchain-trusty-3.9 + packages: + - build-essential + - scons + - pkg-config + - libx11-dev + - libxcursor-dev + - libasound2-dev + - libfreetype6-dev + - libgl1-mesa-dev + - libglu1-mesa-dev + - libssl-dev + - libxinerama-dev + - libxrandr-dev + +before_install: + - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install scons ; fi + +install: + - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export GODOT_PLATFORM=osx; else export GODOT_PLATFORM=x11; fi + - git clone --depth=1 https://github.com/nim-lang/Nim.git + - cd Nim + - git checkout devel + - sh ci/build.sh + - export PATH=$PATH:"`pwd`/bin" + - ./koch tools -d:release + - nimble install -y + - cd .. + - git clone --depth=1 https://github.com/godotengine/godot.git godotengine + - cd godotengine + - scons -j 3 platform=$GODOT_PLATFORM + - export GODOT_BIN="`pwd`/bin/godot.$GODOT_PLATFORM.tools.64" + - cd .. + +script: + - set -e + - mkdir godotapi + - nim c -d:release -r godot/godotapigen.nim "$GODOT_BIN" godotapi + - nimble install -y + - nim c -c godotapi/godotall.nim + - nim c -d:release -r docs/docpublish.nim diff --git a/docs/docbuild.nim b/docs/docbuild.nim new file mode 100644 index 0000000..b48368d --- /dev/null +++ b/docs/docbuild.nim @@ -0,0 +1,159 @@ +# Copyright 2017 Xored Software, Inc. + +import threadpool, os, osproc, strutils, sequtils, pegs + +import "../godot/godotapigen.nim" + +const dirs = ["godot"/"core", "godot"/"internal", "godot"/"nim"] +const files = ["godot"/"godotapigen.nim", "godot"/"godotinternal.nim", + "godot"/"godot.nim"] +const indexFile = "docs"/"index.rst" +const gitHubUrl = "https://github.com/pragmagic/godot-nim" + +proc outName(outDir, file: string): string = + outDir / file.extractFilename().changeFileExt("html") + +template quoted(s: string): string = + ('"' & s & '"') + +proc execOrFail(cmd: string) = + echo "[exec] " & cmd + let ret = execShellCmd(cmd) + if ret != 0: + raise newException( + Exception, "Command quit with exit code " & $ret & ": " & cmd) + +template withDir(dir: string, body: typed) = + let curDir = getCurrentDir() + setCurrentDir(dir) + try: + body + finally: + setCurrentDir(curDir) + +iterator walkDirRec(dir: string, filter: set[PathComponent], + extensions: openarray[string]): string = + for file in walkDirRec(dir, filter): + if not extensions.anyIt(file.endsWith(it)): continue + yield file + +proc genApiFiles(targetDir, godotBin: string) = + let jsonFile = targetDir / "api.json" + try: + execOrFail(quoted(godotBin) & + " --gdnative-generate-json-api " & quoted(jsonFile)) + except: + # this fails unstably even if api.json is created successfully + discard + if not fileExists(jsonFile): + raise newException(Exception, "Failed to generate Godot API wrappers") + + genApi(targetDir, jsonFile) + + writeFile(targetDir / "nim.cfg", "path=\"$projectdir/../../godot\"") + +proc extractVersion(nimbleFile: string): string = + let contents = readFile(nimbleFile) + var matches: array[1, string] + doAssert match(contents, peg"""'version' \s* '=' \s* '"' {@} '"' """, matches) + result = matches[0] + +proc fixupHrefs(file: string) = + var contents = readFile(file) + contents = contents.replacef( + peg"""'href="' ('internal'/'core'/'nim') '/' {@} '"' """, + "href=\"$#\"") + if file.contains("godotapi"): + contents = contents.replacef( + peg"""'href="' {('godotinternal' / 'godot') '.html"'} """, + "href=\"../$#") + writeFile(file, contents) + +proc getGitHash(): string = + result = execProcess("git rev-parse HEAD") + if not result.isNil and result.len > 0: + result = result.replace("\L", "").replace("\r", "") + +proc buildDocs*(outDir, godotNimDir, godotBin: string) = + removeDir(outDir) + createDir(outDir) + let outDirAbs = expandFilename(outDir) + let godotBinAbs = expandFilename(godotBin) + + setCurrentDir(godotNimDir) + + let godotNimVersion = extractVersion("godot.nimble") + putEnv("godotnimversion", godotNimVersion) + putEnv("godotnimgithub", gitHubUrl) + let gitCommit = getGitHash() + + var allNimFiles = newSeq[string]() + allNimFiles.add(files) + for dir in dirs: + for file in walkDirRec(dir, {pcFile, pcDir}, [".nim"]): + allNimFiles.add(file) + for file in allNimFiles: + spawn execOrFail( + "nim doc -o:" & quoted(outName(outDirAbs, file)) & + " --git.url:" & quoted(gitHubUrl) & + " --git.commit:" & quoted(gitCommit) & + ' ' & quoted(file)) + + let godotApiFolder = outDirAbs / "godotapi" + createDir(godotApiFolder) + genApiFiles(godotApiFolder, godotBinAbs) + for file in walkDirRec(godotApiFolder, {pcFile, pcDir}, [".nim"]): + spawn execOrFail("nim doc " & quoted(file)) + + sync() + + var gitHash: string + withDir(godotBinAbs.parentDir()): + gitHash = getGitHash() + if gitHash.isNil or gitHash.len == 0: + raise newException(Exception, + "Godot executable is not under Git repository") + + var indexContent = readFile(indexFile) + var apiList = newStringOfCap(4096) + for file in walkDirRec(godotApiFolder, {pcFile, pcDir}): + if not file.endsWith(".html"): + removeFile(file) + else: + let moduleHtml = file.extractFileName() + let moduleName = moduleHtml.changeFileExt("") + apiList.add("* `" & moduleName & " `_\L") + indexContent = indexContent.replace("$GODOTAPI_CHANGESET_HASH", gitHash). + replace("$AUTO_GENERATED_GODOTAPI_LIST", apiList). + replace("$GODOTNIM_GITHUB_URL", gitHubUrl) + + let tmpRst = outDirAbs/"index.rst" + writeFile(tmpRst, indexContent) + try: + execOrFail("nim rst2html -o:" & quoted(outName(outDirAbs, tmpRst)) & + ' ' & quoted(tmpRst)) + finally: + removeFile(tmpRst) + + for file in walkDirRec(outDir, {pcFile, pcDir}, [".html"]): + spawn fixupHrefs(file) + + sync() + +when isMainModule: + const outDir = "docgen" + + if not fileExists("godot.nimble"): + echo "Must be executed from godot-nim root dir" + quit(-1) + + let godotBin = getEnv("GODOT_BIN") + if godotBin.len == 0: + echo "GODOT_BIN environment variable must point to Godot executable" + quit(-1) + + try: + buildDocs(outDir, getCurrentDir(), godotBin) + except: + echo getCurrentExceptionMsg() + quit(-1) diff --git a/docs/docpublish.nim b/docs/docpublish.nim new file mode 100644 index 0000000..02d56bb --- /dev/null +++ b/docs/docpublish.nim @@ -0,0 +1,94 @@ +# Copyright 2017 Xored Software, Inc. + +import os, pegs, strutils +import docbuild + +const indexTemplate = """ +godot-nim docs index + +

Documentation of Nim bindings for Godot Engine (GitHub)


+$VERSION_LIST + + +""" + +proc execOrQuit(cmd: string) = + let ret = execShellCmd(cmd) + if ret != 0: + quit(ret) + +proc walkDirRecRelative(dir: string, cb: proc (file: string), start = "") = + for kind, path in walkDir(dir, relative = true): + if kind in {pcFile, pcLinkToFile}: + cb(if start.len > 0: start / path else: path) + elif kind in {pcDir, pcLinkToDir}: + let fullPath = if start.len > 0: start / path else: path + walkDirRecRelative(dir / fullPath, cb, fullPath) + +proc publish(docDir, gitHubToken, repoSlug, branch, tag, changeset: string) = + let release = if branch == "master": branch else: tag + let commitComment = if release == "master": + "Update master documentation for changeset " & changeset + else: + "Update documentation for " & tag + + const repoDir = "gh-pages" + execOrQuit( + "git clone --depth=1 --branch=gh-pages https://github.com/$#.git $#" % + [repoSlug, repoDir]) + try: + removeDir(repoDir/release) + createDir(repoDir/release) + var versionList = newStringOfCap(4096) + for kind, path in walkDir(repoDir, relative = true): + if kind == pcDir and not path.startsWith("."): + versionList.add("$1
" % path) + let index = indexTemplate.replace("$REPO_SLUG", repoSlug). + replace("$VERSION_LIST", versionList) + writeFile(repoDir/"index.html", index) + + walkDirRecRelative(docDir) do (file: string): + createDir(parentDir(repoDir/release/file)) + copyFile(docDir/file, repoDir/release/file) + + setCurrentDir(repoDir) + try: + execOrQuit("git add --all") + execOrQuit("git commit -m \"$#\"" % commitComment) + execOrQuit("git push -fq \"https://$#@github.com/$#.git\" gh-pages" % + [gitHubToken, repoSlug]) + finally: + setCurrentDir("..") + finally: + removeDir(repoDir) + +when isMainModule: + proc getEnvOrQuit(key: string): string = + result = getEnv(key) + if result.len == 0: + echo "Expected environment variable: " & key + quit(1) + + if getEnv("TRAVIS_PULL_REQUEST").len > 0: + quit(0) + + let repoSlug = getEnvOrQuit("TRAVIS_REPO_SLUG") + let branch = getEnvOrQuit("TRAVIS_BRANCH") + let changeset = getEnvOrQuit("TRAVIS_COMMIT") + let tag = getEnv("TRAVIS_TAG") + + # let repoSlug = "pragmagic/godot-nim" + # let branch = "master" + # let changeset = "0fd0101432c1fed1004f50b035fcf74f75f004a8" + # let tag = "" + + let gitHubToken = getEnvOrQuit("GITHUB_TOKEN") + + if branch != "master" and not (tag =~ peg"^ 'v' \d+ '.' \d+ '.' \d+ $"): + quit(0) + + let godotBin = getEnvOrQuit("GODOT_BIN") + + const docDir = "docgen" + buildDocs(docDir, getCurrentDir(), godotBin) + publish(docDir, gitHubToken, repoSlug, branch, tag, changeset) diff --git a/docs/godotapi.rst b/docs/godotapi.rst new file mode 100644 index 0000000..9bea41d --- /dev/null +++ b/docs/godotapi.rst @@ -0,0 +1,12 @@ +=============== +Godot API (Nim) +=============== + +:Godot Git Hash: |godothash| + +.. contents:: + +This is an auto-generated index of Godot API. It's built from Git changeset +$GODOTAPI_CHANGESET_HASH. + +$AUTO_GENERATED_GODOTAPI_LIST \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..d127ea3 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,198 @@ +============================= +Nim bindings for Godot Engine +============================= + +:Author: Ruslan Mustakov +:Version: |godotnimversion| +:GitHub: `$GODOTNIM_GITHUB_URL <$GODOTNIM_GITHUB_URL>`_ + +.. contents:: + +``godot-nim`` library allows to create games on +`Godot Engine `_ with +`Nim programming language `_. Nim is a statically typed +language with an elegant Python-like syntax that compiles to native code. +It is garbage-collected, but its GC supports real-time mode which this library +makes use of. It means the GC will never run during game frames and will use +fixed amount of frame idle time to collect garbage. This leads to no stalls +and close to zero compromise on performance comparing to native languages with +manual memory management. + +If you are not familiar with Nim yet, it is recommended to go through the +`official tutorial `_. + +`VSCode `_ is the recommended editor for +working with Nim code. It is cross-platform and has the excellent +`nim plugin `_ +that supports most of the features you would expect from an IDE. +It also has `godot-tools plugin `_ +which adds features for editing GDScript and Godot resource files. + + +Getting Started +=============== + +Building Godot +-------------- + +The library requires a not yet released Godot version 3.0, which you can +build yourself by running the commands below (requires +`Git `_, +`Python 2.7 `_, +`SCons `_): + +.. code-block:: bash + git clone https://github.com/godotengine/godot.git + cd godot + scons platform= + +where ```` can be ``windows``, ``osx``, ``x11``. After build +is finished, Godot binaries will be under the ``bin`` folder. More details +about compiling Godot can be found in `Godot documentation +`_. + + +Building Nim +------------- + +The library requires a not yet released Nim version 0.17.1, which you can +build yourself by following instructions in the +`Nim repository `_. Make sure to also run +``./koch tools -d:release`` after the steps described there to build ``nimble`` +(package manager) and ``nimsuggest`` (IDE helper tool, +used by VSCode Nim plugin) + + +Creating Project +---------------- + +The fastest way to set up a Godot-Nim project is to use an existing stub: + +.. code-block:: bash + git clone --depth=1 https://github.com/pragmagic/godot-nim-stub.git myproject + +(you can then delete the .git directory within to untie the project from the +stub repository) + +The stub contains the necessary build configuration to compile your code for +desktop and mobile platforms, as well as a couple of very simple scenes to +help you get started. Consult the stub's `README +`_ for information about +compiling the project. + + +Adding Nim to Existing Project +------------------------------ + +If you would like to use Nim in an existing project: + +1. Copy ``nakefile.nim`` file and ``src`` directory from the stub described + in the previous section above your Godot project folder. Adjust paths in + build scripts (``nakefile.nim``, ``src/stub.nimble``) according to your + own project structure. + +2. Copy ``project/nimlib.tres`` to your Godot project folder. It is a + GDNative library resource that contains paths to dynamic libraries + compiled by Nim. + +3. Add ``NimRuntime`` as an `AutoLoad singleton `_ + to your project. To do this, copy ``project/scripts/NimRuntime.gdns`` into + your project and add these lines to ``project.godot``, adjusting path to + ``NimRuntime.gdns`` as necessary: +.. code-block:: cfg + [autoload] + NimRuntime="*res://scripts/NimRuntime.gdns" + + +Next Steps +---------- + +Once you are familiarized with the build process (it's as simple as running +``nake build`` after you are set up), it is recommended to go through +`godotmacros `_ and `godotnim `_ module +documentations. They describe special macros and procedures needed to define +or instantiate Godot objects. After you learned that, the rest is similar to +using any Nim library. These bindings do not limit any of Nim's capabilities, +and you can use any Nim types as fields or parameters of Godot objects and +their procedures (but, obviously, you may not be able to export some of them +to Godot editor or GDScript, unless you define your own converters). + + +Modules +======= + +The binding library consists of three major modules: + +* `godot <#modules-godot-module>`_ - Contains core types and macro definitions. + You need to import this in any module that defines or makes use of Godot + types. + +* `godotinternal <#modules-godotinternal-module>`_ - Contains raw wrappers over + few core types, such as ``GodotVariant``, ``GodotString``, ``GodotNodePath``, + ``GodotDictionary``, pool arrays. These are used by ``godotapigen`` and macro + implementations, and you don't have to use them at all in your code, unless + you want to go into low-level details for some reason. Each of those types + needs to be destructed manually with ``deinit`` procedure. + +* `godotapigen `_ - Wrapper generator based on data from + Godot's ``ClassDB``. You only need to use it as a part of the build process. + + +godot Module +------------ + +Contains core types and macro definitions. You need to import this in any +module that defines or makes use of Godot types. The sumbodules below are +exported and you don't have to import any of them directly. + +* `godotnim `_ Defines ``NimGodotObject`` and Varaint converters + for standard Nim types. +* `godotmacros `_ Defines ``gdobj`` macro for defining + Godot objects. +* `variants `_ ``Variant`` type represents a "dynamic object" + that many Godot procedures make use of. +* `arrays `_ Defines ``Array`` of Variants. +* `basis `_ Defines 3D ``Basis``. +* `colors `_ Defines ARGB ``Color``. +* `dictionaries `_ Defines ``Variant`` -> ``Variant`` + ``Dictionary``. +* `nodepaths `_ Defines ``NodePath`` - a path to a ``Node``. +* `planes `_ Defines 3D ``Plane``. +* `poolarrays `_ Defines pooled arrays: ``PoolByteArray``, + ``PoolIntArray``, ``PoolRealArray``, ``PoolVector2Array``, + ``PoolVector3Array``, ``PoolColorArray``, ``PoolStringArray``. +* `quats `_ Defines ``Quat`` (quaternion) describing object + rotation in 3D space. +* `rect2 `_ Defines ``Rect2`` - a 2D rectangle. +* `rect3 `_ Defines ``Rect3`` - a 3D box. +* `rids `_ Defines ``RID`` - a resource identifier. +* `transform2d `_ Defines ``Transform2D``. +* `transforms `_ Defines ``Transform``. +* `vector2 `_ Defines ``Vector2``. +* `vector3 `_ Defines ``Vector3``. +* `godotbase `_ Defines ``Error`` type and few common math + procedures missing in Nim's standard library. + + +Godot API +--------- + +This is an auto-generated list of Godot API modules. It's built from Godot +changeset `$GODOTAPI_CHANGESET_HASH +`_. + +$AUTO_GENERATED_GODOTAPI_LIST + + +godotinternal Module +-------------------- + +Contains low-level wrappers over Godot types that require manual memory +management. This module is used within ``godot-nim`` implementation and you +don't need to import it unless you know what you are doing. + +* `godotdictionaries `_ +* `godotnodepaths `_ +* `godotpoolarrays `_ +* `godotstrings `_ +* `godotvariants `_ diff --git a/docs/nim.cfg b/docs/nim.cfg new file mode 100644 index 0000000..9d57ecf --- /dev/null +++ b/docs/nim.cfg @@ -0,0 +1 @@ +--threads:on \ No newline at end of file diff --git a/godot.nimble b/godot.nimble index 1788bf7..fb29aea 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.3.0" +version = "0.4.0" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/apigen/apigen.nim b/godot/apigen/apigen.nim deleted file mode 100644 index 48c2348..0000000 --- a/godot/apigen/apigen.nim +++ /dev/null @@ -1,3 +0,0 @@ -{.warning: "'apigen.apigen' module is deprecated and will be removed in v0.4.0. Use 'godotapigen' instead.".} - -include "../godotapigen.nim" \ No newline at end of file diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 6be9bf6..4c96817 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,7 +1,8 @@ # Copyright 2017 Xored Software, Inc. import hashes -import internal / [godotstrings, godotdictionaries, godotvariants] +import internal.godotstrings, internal.godotdictionaries, + internal.godotvariants type Dictionary* = ref object diff --git a/godot/core/nim.cfg b/godot/core/nim.cfg new file mode 100644 index 0000000..f1fb6a7 --- /dev/null +++ b/godot/core/nim.cfg @@ -0,0 +1 @@ +--path:"$projectdir/../" \ No newline at end of file diff --git a/godot/core/rids.nim b/godot/core/rids.nim index 82a5154..aece8c5 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -2,7 +2,7 @@ import internal.godotobjects type RID* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] proc initRID(dest: var RID) {. importc: "godot_rid_new".} diff --git a/godot/core/variants.nim b/godot/core/variants.nim index f1efd9e..6e875c3 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -1,7 +1,7 @@ import tables -import internal / [godotobjects, godotvariants, godotpoolarrays, godotstrings, - godotnodepaths] +import internal.godotobjects, internal.godotvariants, internal.godotpoolarrays, + internal.godotstrings, internal.godotnodepaths type Variant* = ref object diff --git a/godot/godot.nim b/godot/godot.nim index bf7eaa5..3514ea2 100644 --- a/godot/godot.nim +++ b/godot/godot.nim @@ -1,13 +1,17 @@ # Copyright 2017 Xored Software, Inc. import core.godotbase, godotinternal -import core / [vector2, rect2, vector3, transform2d, planes, quats] -import core / [rect3, basis, transforms, colors, nodepaths, rids] -import core / [dictionaries, arrays, poolarrays, variants] +import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes, + core.quats +import core.rect3, core.basis, core.transforms, core.colors, core.nodepaths, + core.rids +import core.dictionaries, core.arrays, core.poolarrays, core.variants -import nim / [godotmacros, godotnim] +import nim.godotmacros, nim.godotnim export godotbase, vector2, rect2, vector3, transform2d, planes, quats, rect3, basis, transforms, colors, nodepaths, rids, dictionaries, arrays, poolarrays, variants export godotmacros, godotnim + +export GodotPropertyHint, GodotPropertyUsageFlags \ No newline at end of file diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 42b3ea3..510251d 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -1,6 +1,6 @@ # Copyright 2017 Xored Software, Inc. -import streams, json, ospaths, strutils, times, sets, tables +import streams, json, os, strutils, times, sets, tables import sequtils, algorithm import compiler / [ast, renderer, idents, astalgo] @@ -261,8 +261,8 @@ const standardTypes = toSet( "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) -const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32", - "cint", "int", "Error"]) +const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", + "int32", "cint", "int", "Error"]) const int64Types = toSet(["uint64", "int64"]) const intTypes = union(smallIntTypes, int64Types) const float64Types = toSet(["float64", "cdouble"]) @@ -339,6 +339,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var body: PNode if not withImplementation: body = newNode(nkEmpty) + elif godotMethodName == "_init" and typ.godotName == "Object": + # It's not real (calling it crashes) and will be removed later, + # but we use init() convention in Nim, so it needs to work. + body = newNode(nkStmtList).addChain( + newNode(nkDiscardStmt).addChain(newNode(nkEmpty))) else: var methodBindName = toNimStyle( typ.name & "_" & godotMethodName & "_method_bind") @@ -410,7 +415,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], let isStandardType = arg.typ in standardTypes let isWrappedType = arg.typ in wrapperTypes let convArg = if not varargsName.isNil: - getInternalPtr(newCall("toGodot", argName), "Variant") + getInternalPtr(newCall("toVariant", argName), "Variant") elif isWrappedType: getInternalPtr(argName, arg.typ) elif isStandardType: newCall("unsafeAddr", argName) elif arg.typ == "string": newCall("unsafeAddr", @@ -440,7 +445,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ) else: argConversions.add(newNode(nkVarSection).addChain( - newIdentDefs(ident("idx"), newNode(nkEmpty), newIntLit(staticArgsLen)))) + newIdentDefs(ident("idx"), newNode(nkEmpty), + newIntLit(staticArgsLen)))) let argLoop = newNode(nkWhileStmt) argConversions.add(argLoop) argLoop.add(newInfix(ident("idx"), ident("<"), argLenNode) @@ -544,7 +550,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if isVariantRet: let convErrDef = newNode(nkLetSection).addChain( newIdentDefs(ident("convErr"), newNode(nkEmpty), - newCall("fromGodot", ident("result"), newCall("newVariant", retValIdent)))) + newCall("fromVariant", ident("result"), + newCall("newVariant", retValIdent)))) let convCheck = newIfStmt( newInfix(ident("convErr"), ident("!="), newDotExpr(ident("ConversionResult"), ident("OK"))), @@ -726,7 +733,7 @@ proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool = curTyp = types.getOrDefault(curTyp.baseName) result = curTyp.isNil -proc genTypeFile*(types: var Table[string, GodotType], targetDir: string) = +proc genTypeFile(types: var Table[string, GodotType], targetDir: string) = for typ in types.values(): types.incDerivedCount(typ.baseName) @@ -755,6 +762,9 @@ proc genTypeFile*(types: var Table[string, GodotType], targetDir: string) = renderModule(godotApiTypesTree, targetDir / "godottypes.nim") proc genApi*(targetDir: string, apiJsonFile: string) = + ## Generates .nim files in the ``targetDir`` based on the ``apiJsonFile``. + ## The JSON file can be generated by executing Godot with + ## ``--gdnative-generate-json-api `` parameters. let apiJson = parseJson(newFileStream(apiJsonFile), apiJsonFile.extractFilename()) var megaImport = newStringOfCap(64 * 1024) diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index 0fd8cb9..754900a 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -1,8 +1,8 @@ # Copyright 2017 Xored Software, Inc. -import internal / [ - godotobjects, godotarrays, godotnodepaths, godotpoolarrays, - godotstrings, godotvariants, godotdictionaries] +import internal.godotobjects, internal.godotarrays, internal.godotnodepaths, + internal.godotpoolarrays, internal.godotstrings, internal.godotvariants, + internal.godotdictionaries export godotobjects, godotarrays, godotnodepaths, godotpoolarrays, godotstrings, godotvariants, godotdictionaries @@ -206,7 +206,7 @@ type proc godotScriptRegisterProperty*(libHandle: pointer; name: cstring; path: cstring; - attr: var GodotPropertyAttributes; + attr: ptr GodotPropertyAttributes; setFunc: GodotPropertySetFunc; getFunc: GodotPropertyGetFunc) {. importc: "godot_nativescript_register_property".} @@ -270,6 +270,9 @@ proc getClassName*(o: ptr GodotObject): string = # There are physics type not known by ClassDB result = result[0..result.len-3] +proc getGodotSingleton*(name: cstring): ptr GodotObject {. + importc: "godot_global_get_singleton".} + # System Functions proc godotAlloc*(bytes: cint): pointer {. diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index f63f3ce..ac53bfb 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -2,7 +2,7 @@ type GodotArray* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] import hashes import godotobjects, godotpoolarrays, godotvariants, godotstrings diff --git a/godot/internal/godotdictionaries.nim b/godot/internal/godotdictionaries.nim index 24fee10..d00d60c 100644 --- a/godot/internal/godotdictionaries.nim +++ b/godot/internal/godotdictionaries.nim @@ -2,7 +2,7 @@ type GodotDictionary* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] import godotarrays, godotvariants, godotstrings diff --git a/godot/internal/godotnodepaths.nim b/godot/internal/godotnodepaths.nim index d05e175..2a84fe3 100644 --- a/godot/internal/godotnodepaths.nim +++ b/godot/internal/godotnodepaths.nim @@ -4,7 +4,7 @@ import godotstrings type GodotNodePath* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] proc initGodotNodePath*(dest: var GodotNodePath; s: GodotString) {. importc: "godot_node_path_new".} diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index ab4504c..98d61bc 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -2,22 +2,22 @@ type GodotPoolByteArray* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] GodotPoolIntArray* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] GodotPoolRealArray* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] GodotPoolStringArray* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] GodotPoolVector2Array* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] GodotPoolVector3Array* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] GodotPoolColorArray* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] import godotstrings, godotarrays -import core / [godotbase, colors, vector2, vector3] +import core.godotbase, core.colors, core.vector2, core.vector3 # byte diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index 9477ea9..f47a174 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -2,7 +2,7 @@ type GodotString* {.byref.} = object - p: pointer + data: array[sizeof(int), byte] proc initGodotString(dest: var GodotString) {. importc: "godot_string_new".} diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 39d36eb..81ce797 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -46,7 +46,7 @@ type expected*: VariantType GodotVariant* {.byref.} = object - data: array[16 + sizeof(int), byte] + data: array[4 + sizeof(int) div 4, float32] import godotobjects, godotarrays, godotpoolarrays, godotstrings, godotnodepaths, godotdictionaries diff --git a/godot/internal/nim.cfg b/godot/internal/nim.cfg new file mode 100644 index 0000000..f1fb6a7 --- /dev/null +++ b/godot/internal/nim.cfg @@ -0,0 +1 @@ +--path:"$projectdir/../" \ No newline at end of file diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index fd7def7..e0b81bc 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -32,6 +32,19 @@ type ParseError = object of Exception +proc godotToNim[T](val: Variant): (T, ConversionResult) = + mixin fromVariant + result[1] = fromVariant(result[0], val) + +proc nimToGodot[T](val: T): Variant = + mixin toVariant + when compiles(toVariant(val)): + result = toVariant(val) + else: + printError("Failed to convert Nim value of type " & T.name & + " into Variant") + initNilVariant(result) + template parseError(node: NimNode, msg: string) = raise newException(ParseError, lineinfo(node) & ": " & msg) @@ -249,7 +262,7 @@ macro invokeVarArgs(procIdent, objIdent; if hasReturnValue: let theCall = newNimNode(nnkBracketExpr).add(newNimNode(nnkDotExpr).add( - newCall("toGodot", invocation), ident("godotVariant"))) + newCall("toVariant", invocation), ident("godotVariant"))) branchBody.add(getAst(initGodotVariantCall(ident("result"), theCall))) else: branchBody.add(invocation) @@ -291,11 +304,18 @@ proc nimDestroyRefFunc(obj: ptr GodotObject, methData: pointer, # so nothing to do here. discard -proc refcountIncremented*(obj: NimGodotObject) = - GC_ref(obj) +proc refcountIncremented(obj: ptr GodotObject, methodData: pointer, + userData: pointer, numArgs: cint, + args: var array[MAX_ARG_COUNT, ptr GodotVariant]): + GodotVariant {.noconv.} = + GC_ref(cast[NimGodotObject](userData)) -proc refcountDecremented*(obj: NimGodotObject): bool = - GC_unref(obj) +proc refcountDecremented(obj: ptr GodotObject, methodData: pointer, + userData: pointer, numArgs: cint, + args: var array[MAX_ARG_COUNT, ptr GodotVariant]): + GodotVariant {.noconv.} = + GC_unref(cast[NimGodotObject](userData)) + initGodotVariant(result, false) # destroy when Nim decides template registerGodotClass(classNameIdent, classNameLit, isRef, baseNameLit, createFuncIdent; isTool: bool) = @@ -306,6 +326,8 @@ template registerGodotClass(classNameIdent, classNameLit, isRef, nimObj.setGodotObject(obj) GC_ref(nimObj) result = cast[pointer](nimObj) + when compiles(nimObj.init()): + nimObj.init() let createFuncObj = GodotInstanceCreateFunc( createFunc: createFuncIdent @@ -356,19 +378,23 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, getFunc: getFuncIdent ) {.push warning[ProveInit]: off.} # false warning, Nim bug - var attr = GodotPropertyAttributes( - typ: ord(godotVariantType(propTypeIdent)), - hintString: hintTipLit.toGodotString(), + var hintStr = hintTipLit.toGodotString() + let attr = GodotPropertyAttributes( + typ: ord(variantType(propTypeIdent)), + hintString: hintStr, hint: GodotPropertyHint.hintIdent, usage: GodotPropertyUsageFlags.usageIdent ) {.push warning[ProveInit]: on.} when hasDefaultValue: - attr.defaultValue = (defaultValueNode).toGodot() + attr.defaultValue = (defaultValueNode).toVariant().godotVariant[] godotScriptRegisterProperty(getNativeLibHandle(), classNameLit, propNameLit, - attr, setFunc, getFunc) + unsafeAddr attr, setFunc, getFunc) + hintStr.deinit() + static: - import strutils, sets + import strutils, sets, sequtils + proc toGodotStyle(s: string): string {.compileTime.} = result = newStringOfCap(s.len + 10) for c in s: @@ -469,7 +495,6 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = GodotVariant {.noconv.} = let self = cast[classNameIdent](userData) const isStaticCall = methodNameLit == cstring"_ready" or - methodNameLit == cstring"_init" or methodNameLit == cstring"_enter_tree" or methodNameLit == cstring"_exit_tree" or methodNameLit == cstring"_enter_world" or @@ -520,25 +545,70 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = if isRef: # add ref/unref for types inherited from Reference - let noArgs = newSeq[NimNode]() - result.add(getAst( - registerGodotMethod(classNameLit, classNameIdent, ident("refcountIncremented"), - cstring"_refcount_incremented", 0, 0, - noArgs, genSym(nskProc, "refcount_incremented"), - ident("false")))) - result.add(getAst( - registerGodotMethod(classNameLit, classNameIdent, ident("refcountDecremented"), - cstring"_refcount_decremented", 0, 0, - noArgs, genSym(nskProc, "refcount_decremented"), - ident("true")))) + template registerRefIncDec(classNameLit) = + let refInc = GodotInstanceMethod( + meth: refcountIncremented + ) + let refDec = GodotInstanceMethod( + meth: refcountDecremented + ) + godotScriptRegisterMethod(getNativeLibHandle(), classNameLit, + cstring"_refcount_incremented", + GodotMethodAttributes(), refInc) + godotScriptRegisterMethod(getNativeLibHandle(), classNameLit, + cstring"_refcount_decremented", + GodotMethodAttributes(), refDec) + result.add(getAst(registerRefIncDec(classNameLit))) {.push warning[Deprecated]: off.} -# immediate macros are deprecated, but `untyped` doesnt make it immediate, +# immediate macros are deprecated, but `untyped` doesn't make it immediate, # as the warning and the documentation claim. macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = + ## Generates Godot type. Self-documenting example: + ## + ## .. code-block:: nim + ## import godot, node + ## + ## gdobj MyObj of Node: + ## var myField: int + ## ## Not exported to Godot (i.e. editor will not see this field). + ## + ## var myString* {.gdExport, hint: Length, tip: "20".}: string + ## ## Exported to Godot as ``my_string``. + ## ## Editor will limit this string to length 20. + ## ## ``hint` is a value of ``GodotPropertyHint`` enum. + ## ## ``tip`` depends on the value of ``hint``, its format is described + ## ## in ``GodotPropertyHint`` documentation. + ## + ## method ready*() = + ## ## Exported methods are exported to Godot by default, + ## ## and their Godot names are prefixed with ``_`` + ## ## (in this case ``_ready``) + ## print("I am ready! myString is: " & myString) + ## + ## proc myProc*() {.gdExport.} = + ## ## Exported to Godot as ``my_proc`` + ## print("myProc is called! Incrementing myField.") + ## inc myField + ## + ## If parent type is omitted, the type is inherited from ``Object``. + ## + ## ``tool`` specifier can be added to mark the type as an + ## `editor plugin `_: + ## + ## .. code-block:: nim + ## import godot, editor_plugin + ## + ## gdobj(MyTool of EditorPlugin, tool): + ## method enterTree*() = + ## print("MyTool initialized!") + ## + ## Objects can be instantiated by invoking + ## `gdnew `_ or by using + ## `load `_ or any other way + ## that you can find in `Godot API `_. let typeDef = parseType(definition, callsite()) result = genType(typeDef) {.push warning[Deprecated]: on.} - diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 7639c78..5d26891 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -10,15 +10,28 @@ import core.vector2, core.rect2, core.arrays, core.poolarrays, core.variants import godotinternal -## Definition of NimGodotObject and converters for built-in types. +## This module defines ``NimGodotObject`` and ``toVariant``/``fromVariant`` +## converters for Nim types. The converters are used by +## `gdobj `_ macro to import/export +## values from/to Godot (editor, GDScript). +## +## You can also allow conversion of any custom type ``MyType`` by implementing: +## +## .. code-block:: nim +## proc variantType*(T: typedesc[MyType]): VariantType +## proc toVariant*(self: MyType): Variant +## proc fromVariant*(self: var MyType, val: Variant): ConversionResult type NimGodotObject* = ref object of RootObj + ## The base type all Godot types inherit from. + ## Manages lifecycle of the wrapped GodotObject. godotObject: ptr GodotObject isExternalRef: bool isOwn: bool ConversionResult* {.pure.} = enum + ## Conversion result to return from ``fromVariant`` procedure. OK, TypeError, ## Type mismatch @@ -41,7 +54,11 @@ type SomeGodotOrNum = SomeGodot or SomeSignedInt or SomeUnsignedInt or SomeFloat CallError* = object of Exception + ## Raised by wrappers in case of an incorrect dynamic invocation. + ## For example, if incorrect number of arguments were passed or they had + ## unexpected types. err*: VariantCallError + ## The error as returned by Godot ObjectInfo = object constructor: proc(): NimGodotObject {.gcsafe, nimcall.} @@ -49,20 +66,24 @@ type isNative: bool isRef: bool -template printWarning*(warn: typed) = +template printWarning*(warning: typed) = + ## Prints ``warning`` to Godot log, adding filename and line information. let (filename, line) = instantiationInfo() - godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint) + godotPrintWarning(cstring($warning), nil, cstring(filename), line.cint) -template printError*(err: typed) = +template printError*(error: typed) = + ## Prints ``error`` to Godot log, adding filename and line information. let (filename, line) = instantiationInfo() - godotPrintError(cstring($err), nil, cstring(filename), line.cint) + godotPrintError(cstring($error), nil, cstring(filename), line.cint) proc print*(message: string) {.inline.} = + ## Prints ``message`` to Godot log. var s = message.toGodotString() godotPrint(s) s.deinit() proc print*(message: cstring) {.inline.} = + ## Prints ``message`` to Godot log. var s = message.toGodotString() godotPrint(s) s.deinit() @@ -141,7 +162,9 @@ macro isReference(T: typedesc): bool = else: ident("false") template registerClass*(T: typedesc; godotClassName: cstring, - isNativeParam: bool) = + native: bool) = + ## Registers the specified Godot type. + ## Used by ``gdobj`` macro and `godotapigen `_. if classRegistry.isNil: classRegistry = newTable[cstring, ObjectInfo]() let constructor = proc(): NimGodotObject = @@ -154,21 +177,21 @@ template registerClass*(T: typedesc; godotClassName: cstring, let objInfo = ObjectInfo( constructor: constructor, baseNativeClass: base, - isNative: isNativeParam, + isNative: native, isRef: isRef ) classRegistry[godotClassName] = objInfo static: let objInfoStatic = ObjectInfo( baseNativeClass: base, - isNative: isNativeParam, - isRef: isRef + isNative: native, + isRef: isRef, ) classRegistryStatic[godotClassName] = objInfoStatic when isRef: static: refClasses.add(T.name) - when isNativeParam: + when native: static: nativeClasses.add(T.name) @@ -187,6 +210,9 @@ proc newNimGodotObject[T: NimGodotObject]( result.godotObject.reference() proc asNimGodotObject*[T: NimGodotObject](godotObject: ptr GodotObject): T = + ## Wraps ``godotObject`` into Nim type ``T``. + ## This is used by `godotapigen `_ and should rarely be + ## used by anything else. if godotObject.isNil: return nil let userDataPtr = godotObject.getUserData() if not userDataPtr.isNil: @@ -202,15 +228,24 @@ proc newVariant*(obj: NimGodotObject): Variant {.inline.} = newVariant(obj.godotObject) proc asObject*[T: NimGodotObject](v: Variant): T {.inline.} = + ## Converts ``v`` to object of type ``T``. + ## Returns ``nil`` if the conversion cannot be performed + ## (``v``'s type is not an Object or it's an object of an incompatible type) asNimGodotObject[T](v.asGodotObject()) proc asObject*(v: Variant, T: typedesc[NimGodotObject]): T {.inline.} = + ## Converts ``v`` to object of type ``T``. + ## Returns ``nil`` if the conversion cannot be performed + ## (``v``'s type is not an Object or it's an object of an incompatible type) asNimGodotObject[T](v.asGodotObject()) proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = ## Converts the ``obj`` into the specified type. ## Returns ``nil`` if the conversion cannot be performed ## (the ``obj`` is not of the type ``T``) + ## + ## This can be used either in dot notation (``node.as(Button)``) or + ## infix notation (``node as Button``). if obj.isNil or not (obj of T): when not defined(release): if not obj.isNil: @@ -220,9 +255,6 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = else: result = T(obj) -proc getSingletonGodot*(name: cstring): ptr GodotObject {. - importc: "godot_global_get_singleton".} - proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) result.strVal = s @@ -241,8 +273,11 @@ macro toGodotName(T: typedesc): cstring = ident("cstring"), newRStrLit(godotName)) proc getSingleton*[T: NimGodotObject](): T = + ## Returns singleton of type ``T``. Normally, this should not be used, + ## because `godotapigen `_ wraps singleton methods so that + ## singleton objects don't have to be provided as parameters. const godotName = toGodotName(T) - let singleton = getSingletonGodot(godotName) + let singleton = getGodotSingleton(godotName) if singleton.isNil: printError("Tried to get non-existing singleton of type " & $godotName) else: @@ -285,6 +320,7 @@ proc newOwnObj[T: NimGodotObject](name: cstring): T = ret.deinit() proc gdnew*[T: NimGodotObject](): T = + ## Instantiates new object of type ``T``. const godotName = toGodotName(T) const objInfo = classRegistryStatic[godotName] result = when objInfo.isNative: @@ -292,6 +328,7 @@ proc gdnew*[T: NimGodotObject](): T = else: newOwnObj[T](godotName) proc newCallError*(err: VariantCallError): ref CallError = + ## Instantiates ``CallError`` from Godot ``err``. let msg = case err.error: of VariantCallErrorType.OK, VariantCallErrorType.InvalidMethod, @@ -307,6 +344,8 @@ proc newCallError*(err: VariantCallError): ref CallError = result.err = err proc newConversionError*(err: ConversionResult): ref ValueError = + ## Instantiates error raised by `godotapigen `_ + ## generated code in case of a conversion error. let msg = case err: of ConversionResult.TypeError: "Failed to convert the return value into Nim type" @@ -317,28 +356,32 @@ proc newConversionError*(err: ConversionResult): ref ValueError = result = newException(ValueError, msg) -proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} = - ## Used from destructor - nimObj.godotObject = nil - proc setGodotObject*(nimObj: NimGodotObject, obj: ptr GodotObject) {.inline.} = + ## Used from Godot constructor. Don't call this. assert(not obj.isNil) assert(nimObj.godotObject.isNil) # reassignment is not allowed nimObj.godotObject = obj proc setOwn*(nimObj: NimGodotObject) {.inline.} = + ## Used from Godot constructor. Don't call this. nimObj.isOwn = true +proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} = + ## Used from Godot destructor. Don't call this. + nimObj.godotObject = nil + proc godotObject*(nimObj: NimGodotObject): ptr GodotObject {.inline.} = + ## Returns internal poitner to ``GodotObject``. Use only if you know what + ## you are doing. nimObj.godotObject -proc godotVariantType*(T: typedesc[NimGodotObject]): VariantType {.inline.} = +proc variantType*(T: typedesc[NimGodotObject]): VariantType {.inline.} = VariantType.Object -proc toGodot*(self: NimGodotObject): Variant {.inline.} = +proc toVariant*(self: NimGodotObject): Variant {.inline.} = newVariant(self.godotObject) -proc fromGodot*[T: NimGodotObject](self: var T, +proc fromVariant*[T: NimGodotObject](self: var T, val: Variant): ConversionResult = if val.getType() == VariantType.Object: let objPtr = val.asGodotObject() @@ -350,27 +393,27 @@ proc fromGodot*[T: NimGodotObject](self: var T, else: result = ConversionResult.TypeError -proc godotVariantType*(T: typedesc[enum]): VariantType {.inline.} = +proc variantType*(T: typedesc[enum]): VariantType {.inline.} = VariantType.Int -proc toGodot*[T: enum](self: T): Variant {.inline.} = +proc toVariant*[T: enum](self: T): Variant {.inline.} = newVariant(int64(ord(self))) -proc fromGodot*[T: enum](self: var T, +proc fromVariant*[T: enum](self: var T, val: Variant): ConversionResult {.inline.} = if val.getType() == VariantType.Int: self = T(val.asInt()) else: result = ConversionResult.TypeError -proc toGodot*(self: Variant): Variant {.inline.} = +proc toVariant*(self: Variant): Variant {.inline.} = self -proc fromGodot*(self: var Variant, +proc fromVariant*(self: var Variant, val: Variant): ConversionResult {.inline.} = self = newVariant(val) -proc godotVariantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} = +proc variantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} = when T is SomeSignedInt or T is SomeUnsignedInt: VariantType.Int elif T is bool: @@ -426,10 +469,10 @@ proc godotVariantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} = else: VariantType.Nil -proc toGodot*[T: SomeGodotOrNum](val: T): Variant {.inline.} = +proc toVariant*[T: SomeGodotOrNum](val: T): Variant {.inline.} = newVariant(val) -proc fromGodot*[T: SomeSignedInt or SomeUnsignedInt]( +proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( self: var T, val: Variant): ConversionResult = if val.getType() != VariantType.Int: result = ConversionResult.TypeError @@ -443,7 +486,7 @@ proc fromGodot*[T: SomeSignedInt or SomeUnsignedInt]( else: self = T(intVal) -proc fromGodot*[T: SomeFloat](self: var T, val: Variant): ConversionResult = +proc fromVariant*[T: SomeFloat](self: var T, val: Variant): ConversionResult = if val.getType() == VariantType.Real: self = T(val.asReal()) elif val.getType() == VariantType.Int: @@ -451,8 +494,8 @@ proc fromGodot*[T: SomeFloat](self: var T, val: Variant): ConversionResult = else: result = ConversionResult.TypeError -proc fromGodot*[T: SomeGodot](self: var T, val: Variant): ConversionResult = - if godotVariantType(T) != val.getType(): +proc fromVariant*[T: SomeGodot](self: var T, val: Variant): ConversionResult = + if variantType(T) != val.getType(): return ConversionResult.TypeError when self is bool: self = val.asBool() @@ -506,13 +549,13 @@ proc fromGodot*[T: SomeGodot](self: var T, val: Variant): ConversionResult = # mustn't reach this result = ConversionError.TypeError -proc godotVariantType*(T: typedesc[string]): VariantType {.inline.} = +proc variantType*(T: typedesc[string]): VariantType {.inline.} = VariantType.String -proc toGodot*(s: string): Variant {.inline.} = +proc toVariant*(s: string): Variant {.inline.} = newVariant(s) -proc fromGodot*(s: var string, val: Variant): ConversionResult = +proc fromVariant*(s: var string, val: Variant): ConversionResult = if val.getType() == VariantType.String: s = val.asString() elif val.getType() == VariantType.Nil: @@ -520,20 +563,20 @@ proc fromGodot*(s: var string, val: Variant): ConversionResult = else: result = ConversionResult.TypeError -proc godotVariantType*(T: typedesc[seq]): VariantType = +proc variantType*(T: typedesc[seq]): VariantType = VariantType.Array -proc godotVariantType*(T: typedesc[array]): VariantType = +proc variantType*(T: typedesc[array]): VariantType = VariantType.Array -proc toGodot*[T](s: openarray[T]): Variant = +proc toVariant*[T](s: openarray[T]): Variant = var arr = newArray() mixin toGodot for item in s: - arr.add(toGodot(item)) + arr.add(toVariant(item)) result = newVariant(arr) -proc fromGodot*[T](s: var seq[T], val: Variant): ConversionResult = +proc fromVariant*[T](s: var seq[T], val: Variant): ConversionResult = if val.getType() != VariantType.Array: result = ConversionResult.TypeError else: @@ -541,12 +584,12 @@ proc fromGodot*[T](s: var seq[T], val: Variant): ConversionResult = s = newSeq[T](arr.len) for idx, item in arr: mixin fromGodot - let convResult = fromGodot(s[idx], item) + let convResult = fromVariant(s[idx], item) if convResult != ConversionResult.OK: s = nil return convResult -proc fromGodot*[T: array](s: var T, val: Variant): ConversionResult = +proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult = if val.getType() != VariantType.Array: result = ConversionResult.TypeError else: @@ -555,21 +598,21 @@ proc fromGodot*[T: array](s: var T, val: Variant): ConversionResult = return ConversionResult.TypeError for idx, item in arr: mixin fromGodot - let convResult = fromGodot(s[idx], item) + let convResult = fromVariant(s[idx], item) if convResult != ConversionResult.OK: return convResult -proc godotVariantType*(T: typedesc[Table|TableRef]): VariantType {.inline.} = +proc variantType*(T: typedesc[Table|TableRef]): VariantType {.inline.} = VariantType.Dictionary -proc toGodot*[T: Table or TableRef](t: T): Variant = +proc toVariant*[T: Table or TableRef](t: T): Variant = var dict = newDictionary() mixin toGodot for k, v in t.pairs(): - dict[toGodot(k)] = toGodot(v) + dict[toVariant(k)] = toVariant(v) result = newVariant(dict) -proc fromGodot*[T: Table or TableRef](t: var T, val: Variant): ConversionResult = +proc fromVariant*[T: Table or TableRef](t: var T, val: Variant): ConversionResult = if val.getType() != VariantType.Dictionary: result = ConversionResult.TypeError else: @@ -582,31 +625,18 @@ proc fromGodot*[T: Table or TableRef](t: var T, val: Variant): ConversionResult for k, v in dict: var nimKey: type(t.keys()) var nimVal: type(t.values()) - let keyResult = fromGodot(nimKey, k) + let keyResult = fromVariant(nimKey, k) if keyResult != ConversionResult.OK: when t is ref: t = nil return keyResult - let valResult = fromGodot(nimVal, v) + let valResult = fromVariant(nimVal, v) if valResult != ConversionResult.OK: when t is ref: t = nil return valResult t[nimKey] = nimVal -proc godotToNim*[T](val: Variant): (T, ConversionResult) = - mixin fromGodot - result[1] = fromGodot(result[0], val) - -proc nimToGodot*[T](val: T): Variant = - mixin toGodot - when compiles(toGodot(val)): - result = toGodot(val) - else: - printError("Failed to convert Nim value of type " & T.name & - " into Variant") - initNilVariant(result) - {.emit: """/*TYPESECTION*/ void NimMain(void); N_NOINLINE(void, setStackBottom)(void* thestackbottom); @@ -614,6 +644,8 @@ N_NOINLINE(void, setStackBottom)(void* thestackbottom); var nativeLibHandle: pointer proc getNativeLibHandle*(): pointer = + ## Returns NativeScript library handle used to register type information + ## in Godot. Use only if you know what you are doing. return nativeLibHandle proc godot_nativescript_init(handle: pointer) {. diff --git a/godot/nim/nim.cfg b/godot/nim/nim.cfg new file mode 100644 index 0000000..f1fb6a7 --- /dev/null +++ b/godot/nim/nim.cfg @@ -0,0 +1 @@ +--path:"$projectdir/../" \ No newline at end of file diff --git a/godot/nimdoc.cfg b/godot/nimdoc.cfg new file mode 100644 index 0000000..d4e8565 --- /dev/null +++ b/godot/nimdoc.cfg @@ -0,0 +1,5 @@ +doc.item.seesrc = """  Source +Edit +""" \ No newline at end of file From 4d14f624b448d3aecfa4a62d170ff2c1b8a57a39 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 3 Aug 2017 08:55:50 +0700 Subject: [PATCH 039/160] Add a bit of output to docpublish --- docs/docpublish.nim | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/docpublish.nim b/docs/docpublish.nim index 02d56bb..357f696 100644 --- a/docs/docpublish.nim +++ b/docs/docpublish.nim @@ -70,6 +70,7 @@ when isMainModule: quit(1) if getEnv("TRAVIS_PULL_REQUEST").len > 0: + echo "This is a PR build. Skipping." quit(0) let repoSlug = getEnvOrQuit("TRAVIS_REPO_SLUG") @@ -85,6 +86,7 @@ when isMainModule: let gitHubToken = getEnvOrQuit("GITHUB_TOKEN") if branch != "master" and not (tag =~ peg"^ 'v' \d+ '.' \d+ '.' \d+ $"): + echo "This is not master or tagged changeset. Skipping." quit(0) let godotBin = getEnvOrQuit("GODOT_BIN") From c34a2174fa623bf2ddfa4f03e9a6104211066d97 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 3 Aug 2017 11:24:08 +0700 Subject: [PATCH 040/160] Fix Travis PR check --- docs/docpublish.nim | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/docpublish.nim b/docs/docpublish.nim index 357f696..d682aec 100644 --- a/docs/docpublish.nim +++ b/docs/docpublish.nim @@ -69,7 +69,8 @@ when isMainModule: echo "Expected environment variable: " & key quit(1) - if getEnv("TRAVIS_PULL_REQUEST").len > 0: + let pr = getEnv("TRAVIS_PULL_REQUEST") + if pr.len > 0 and pr != "false": echo "This is a PR build. Skipping." quit(0) From e587fdf382864c3787a16cc86a9d52c21da2126a Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 3 Aug 2017 12:14:19 +0700 Subject: [PATCH 041/160] Add Travis status and doc link to README --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 7512cec..7c518a2 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ -# Nim bindings for Godot Engine +# Nim bindings for Godot Engine [![Build Status](https://travis-ci.org/pragmagic/godot-nim.svg?branch=master)](https://travis-ci.org/pragmagic/godot-nim) Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here). -Documentation is coming. You can learn from the [project stub](https://github.com/pragmagic/godot-nim-stub) in the meantime. +Documentation: https://pragmagic.github.io/godot-nim/ ## Links From 0062568dbc2952813f7a6abbeae25d755587b212 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 3 Aug 2017 14:25:02 +0700 Subject: [PATCH 042/160] Add nativescript frame callback, deprecate NimRuntime --- docs/index.rst | 9 --------- godot.nimble | 2 +- godot/godot.nim.cfg | 3 ++- godot/nim/godotnim.nim | 18 +++++++++++++----- godot/nimruntime.nim | 3 +++ 5 files changed, 19 insertions(+), 16 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index d127ea3..4886466 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -95,15 +95,6 @@ If you would like to use Nim in an existing project: GDNative library resource that contains paths to dynamic libraries compiled by Nim. -3. Add ``NimRuntime`` as an `AutoLoad singleton `_ - to your project. To do this, copy ``project/scripts/NimRuntime.gdns`` into - your project and add these lines to ``project.godot``, adjusting path to - ``NimRuntime.gdns`` as necessary: -.. code-block:: cfg - [autoload] - NimRuntime="*res://scripts/NimRuntime.gdns" - - Next Steps ---------- diff --git a/godot.nimble b/godot.nimble index fb29aea..bff8646 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.4.0" +version = "0.4.1" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godot.nim.cfg b/godot/godot.nim.cfg index 9e05300..42e80b0 100644 --- a/godot/godot.nim.cfg +++ b/godot/godot.nim.cfg @@ -1 +1,2 @@ ---path:"$projectdir" \ No newline at end of file +--path:"$projectdir" +-d:useRealtimeGc \ No newline at end of file diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 5d26891..cf8c4ff 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,6 +1,6 @@ # Copyright 2017 Xored Software, Inc. -import tables, typetraits, macros +import tables, typetraits, macros, asyncdispatch import core.godotbase import core.vector2, core.rect2, core.vector3, core.transform2d, @@ -668,14 +668,22 @@ proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. cdecl, exportc, dynlib.} = deallocHeap(runFinalizers = not options[].inEditor, allowGcAfterwards = false) -proc godot_nativescript_thread_enter() {. - cdecl, exportc, dynlib.} = +const nimGcStepLengthUs {.intdefine.} = 2000 +proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = + if asyncdispatch.hasPendingOperations(): + poll(0) + GC_step(nimGcStepLengthUs, false, 0) + +when not defined(release): + onUnhandledException = proc(errorMsg: string) = + printError("Unhandled Nim exception: " & errorMsg) + +proc godot_nativescript_thread_enter() {.cdecl, exportc, dynlib.} = when compileOption("threads"): setupForeignThreadGc() else: print(cstring"A foreign thread is created, but app is compiled without --threads:on. Bad things will happen if Nim code is invoked from this thread.") -proc godot_nativescript_thread_exit() {. - cdecl, exportc, dynlib.} = +proc godot_nativescript_thread_exit() {.cdecl, exportc, dynlib.} = when compileOption("threads"): teardownForeignThreadGc() diff --git a/godot/nimruntime.nim b/godot/nimruntime.nim index 8a392b5..475785f 100644 --- a/godot/nimruntime.nim +++ b/godot/nimruntime.nim @@ -3,6 +3,9 @@ import asyncdispatch import godot, node +{.warning: ("NimRuntime is deprecated - it is no longer necessary to add it " & + "as an AutoLoad class. It will be removed in v0.5.0.").} + gdobj NimRuntime of Node: method enterTree*() = discard getTree().connect("idle_frame", self, "idle", newArray()) From fedd04229a47f4bdeffcab5b760bdd12c91ef127 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 4 Aug 2017 12:21:22 +0700 Subject: [PATCH 043/160] Add varargs and openarray constructors for Array --- godot/core/arrays.nim | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 9ec5b68..58c3942 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -15,14 +15,23 @@ proc godotArray*(arr: Array): ptr GodotArray {.inline.} = proc arrayFinalizer(arr: Array) = arr.godotArray.deinit() -proc newArray*(): Array {.inline.} = - new(result, arrayFinalizer) - initGodotArray(result.godotArray) - proc newArray*(arr: GodotArray): Array {.inline.} = new(result, arrayFinalizer) result.godotArray = arr +import variants + +proc newArray*(s: varargs[Variant]): Array = + new(result, arrayFinalizer) + initGodotArray(result.godotArray) + for v in s: + result.godotArray.add(v.godotVariant[]) + +proc newArray*(s: openarray[Variant]): Array = + result = newArray() + for v in s: + result.godotArray.add(v.godotVariant[]) + import poolarrays proc newArray*(pca: PoolColorArray): Array {.inline.} = @@ -53,8 +62,6 @@ proc newArray*(pba: PoolByteArray): Array {.inline.} = new(result, arrayFinalizer) initGodotArray(result.godotArray, pba.godotPoolByteArray[]) -import variants - proc `[]=`*(self: var Array; idx: int; value: Variant) {.inline.} = self.godotArray[idx.cint] = value.godotVariant[] From afa48455f6ee1871068adc6c2e948ed4b1cdccdf Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 4 Aug 2017 13:23:20 +0700 Subject: [PATCH 044/160] Add -d:useRealtimeGc in Travis build --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 0d0ec4d..3dbd69a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -50,5 +50,5 @@ script: - mkdir godotapi - nim c -d:release -r godot/godotapigen.nim "$GODOT_BIN" godotapi - nimble install -y - - nim c -c godotapi/godotall.nim + - nim c -d:useRealtimeGc -c godotapi/godotall.nim - nim c -d:release -r docs/docpublish.nim From c1c18522033bd3170195b6f0f9f35ce63da5b186 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 5 Aug 2017 12:43:43 +0700 Subject: [PATCH 045/160] Provide type hints for standard types --- godot/nim/godotmacros.nim | 54 +++++--- godot/nim/godotnim.nim | 275 ++++++++++++++++++++++++-------------- 2 files changed, 211 insertions(+), 118 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index e0b81bc..b081d9d 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -11,7 +11,7 @@ type defaultValue: NimNode isNoGodot: bool hint: string - hintTip: string + hintStr: string usage: string isExported: bool @@ -122,7 +122,7 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = for i in 0..<(identDefs.len - 2): let nameNode = identDefs[i].copyNimTree() let hint = removeStrPragma(nameNode, "hint") - let hintTip = removeStrPragma(nameNode, "tip") + let hintStr = removeStrPragma(nameNode, "hintStr") let usage = removeStrPragma(nameNode, "usage") let isGdExport = removePragma(nameNode, "gdExport") if not nameNode.isExported() and isGdExport: @@ -136,7 +136,7 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = typ: identDefs[identDefs.len - 2], defaultValue: identDefs[identDefs.len - 1], hint: hint, - hintTip: hintTip, + hintStr: hintStr, isNoGodot: isNoGodot, usage: usage, isExported: nameNode.isExported() @@ -279,13 +279,13 @@ macro invokeVarArgs(procIdent, objIdent; result.add(newNimNode(nnkElse).add(getAst( printInvokeErr($procIdent.ident, minArgs, maxArgs, numArgsIdent)))) -proc typeError(nimType: cstring, value: string, godotType: VariantType, +proc typeError(nimType: string, value: string, godotType: VariantType, className: cstring, propertyName: cstring): string = result = "Tried to assign incompatible value " & value & " (" & $godotType & ") to field \"" & $propertyName & "\" (" & $nimType & ") of " & $className -proc rangeError(nimType: cstring, value: string, className: cstring, +proc rangeError(nimType: string, value: string, className: cstring, propertyName: cstring): string = result = "Tried to assign the out-of-range value " & value & " to field \"" & $propertyName & "\" (" & $nimType & ") of " & @@ -345,7 +345,7 @@ template registerGodotClass(classNameIdent, classNameLit, isRef, template registerGodotField(classNameLit, classNameIdent, propNameLit, propNameIdent, propTypeLit, propTypeIdent, - setFuncIdent, getFuncIdent, hintTipLit, + setFuncIdent, getFuncIdent, hintStrLit, hintIdent, usageIdent, hasDefaultValue, defaultValueNode) = proc setFuncIdent(obj: ptr GodotObject, methData: pointer, @@ -377,12 +377,27 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, let getFunc = GodotPropertyGetFunc( getFunc: getFuncIdent ) + mixin godotTypeInfo + static: + var typeInfo: GodotTypeInfo + when compiles(godotTypeInfo(propTypeIdent)): + typeInfo = godotTypeInfo(propTypeIdent) + const hintStr = when hintStrLit != "NIM": + hintStrLit + else: + typeInfo.hintStr + const hint = when astToStr(hintIdent) != "NIM": + GodotPropertyHint.hintIdent + else: + typeInfo.hint + const variantType = typeInfo.variantType + + var hintStrGodot = hintStr.toGodotString() {.push warning[ProveInit]: off.} # false warning, Nim bug - var hintStr = hintTipLit.toGodotString() let attr = GodotPropertyAttributes( - typ: ord(variantType(propTypeIdent)), - hintString: hintStr, - hint: GodotPropertyHint.hintIdent, + typ: ord(variantType), + hint: hint, + hintString: hintStrGodot, usage: GodotPropertyUsageFlags.usageIdent ) {.push warning[ProveInit]: on.} @@ -390,7 +405,7 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, attr.defaultValue = (defaultValueNode).toVariant().godotVariant[] godotScriptRegisterProperty(getNativeLibHandle(), classNameLit, propNameLit, unsafeAddr attr, setFunc, getFunc) - hintStr.deinit() + hintStrGodot.deinit() static: import strutils, sets, sequtils @@ -466,9 +481,9 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = # 5. Register fields (properties) for field in obj.fields: if field.isNoGodot: continue - let hintTip = if field.hintTip.isNil: "" - else: field.hintTip - let hint = if field.hint.isNil: "None" + let hintStr = if field.hintStr.isNil: "NIM" + else: field.hintStr + let hint = if field.hint.isNil: "NIM" else: field.hint let usage = if field.usage.isNil: "Default" else: field.usage @@ -476,13 +491,14 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = field.defaultValue.kind != nnkEmpty let hintIdent = ident(hint) let usageIdent = ident(usage) + let nimType = repr field.typ result.add(getAst( registerGodotField(classNameLit, classNameIdent, newCStringLit(toGodotStyle($field.name.basename())), - ident(field.name), newCStringLit($field.typ), + ident(field.name), nimType, field.typ, genSym(nskProc, "setFunc"), genSym(nskProc, "getFunc"), - newStrLitNode(hintTip), hintIdent, usageIdent, + newStrLitNode(hintStr), hintIdent, usageIdent, ident($hasDefaultValue), field.defaultValue))) # 6. Register methods @@ -574,12 +590,12 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = ## var myField: int ## ## Not exported to Godot (i.e. editor will not see this field). ## - ## var myString* {.gdExport, hint: Length, tip: "20".}: string + ## var myString* {.gdExport, hint: Length, hintStr: "20".}: string ## ## Exported to Godot as ``my_string``. ## ## Editor will limit this string to length 20. ## ## ``hint` is a value of ``GodotPropertyHint`` enum. - ## ## ``tip`` depends on the value of ``hint``, its format is described - ## ## in ``GodotPropertyHint`` documentation. + ## ## ``hintStr`` depends on the value of ``hint``, its format is + ## ## described in ``GodotPropertyHint`` documentation. ## ## method ready*() = ## ## Exported methods are exported to Godot by default, diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index cf8c4ff..01f5b55 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -18,9 +18,12 @@ import godotinternal ## You can also allow conversion of any custom type ``MyType`` by implementing: ## ## .. code-block:: nim -## proc variantType*(T: typedesc[MyType]): VariantType +## proc godotTypeInfo*(T: typedesc[MyType]): GodotTypeInfo ## proc toVariant*(self: MyType): Variant ## proc fromVariant*(self: var MyType, val: Variant): ConversionResult +## +## Implementing ``godotTypeInfo`` is optional and is necessary only if you want +## the type to be editable from the editor. type NimGodotObject* = ref object of RootObj @@ -66,6 +69,16 @@ type isNative: bool isRef: bool + GodotTypeInfo* = object + ## Type information provided to Godot editor + variantType*: VariantType + hint*: GodotPropertyHint + hintStr*: string + ## Format depends on the type and the hint. + ## For example, for Enum ``hint`` this is a comma separated list of + ## values. + ## See documentation of ``GodotPropertyHint`` for description of formats. + template printWarning*(warning: typed) = ## Prints ``warning`` to Godot log, adding filename and line information. let (filename, line) = instantiationInfo() @@ -89,7 +102,9 @@ proc print*(message: cstring) {.inline.} = s.deinit() var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo] -var classRegistryStatic {.compileTime.}: TableRef[cstring, ObjectInfo] +var classRegistryStatic* {.compileTime.}: TableRef[cstring, ObjectInfo] + ## Compile-time variable used for implementation of several procedures + ## and macros static: classRegistryStatic = newTable[cstring, ObjectInfo]() @@ -261,13 +276,22 @@ proc newRStrLit(s: string): NimNode {.compileTime.} = static: import strutils + macro toGodotName(T: typedesc): cstring = - let nameStr: string = (($T.getType()[1][1].symbol).split(':')[0]) - let godotName = case nameStr: - of "File", "Directory", "Thread", "Mutex", "Semaphore": - "_" & nameStr - else: - nameStr + var godotName: string + if T is GodotString or T is string: + godotName = "String" + elif T is SomeFloat: + godotName = "float" + elif T is SomeUnsignedInt or T is SomeSignedInt: + godotName = "int" + if godotName.isNil: + let nameStr: string = (($T.getType()[1][1].symbol).split(':')[0]) + godotName = case nameStr: + of "File", "Directory", "Thread", "Mutex", "Semaphore": + "_" & nameStr + else: + nameStr result = newNimNode(nnkCallStrLit).add( ident("cstring"), newRStrLit(godotName)) @@ -375,14 +399,18 @@ proc godotObject*(nimObj: NimGodotObject): ptr GodotObject {.inline.} = ## you are doing. nimObj.godotObject -proc variantType*(T: typedesc[NimGodotObject]): VariantType {.inline.} = - VariantType.Object +proc godotTypeInfo*(T: typedesc[NimGodotObject]): GodotTypeInfo {.inline.} = + GodotTypeInfo( + variantType: VariantType.Object, + hint: GodotPropertyHint.None, + hintStr: toGodotName(T) + ) proc toVariant*(self: NimGodotObject): Variant {.inline.} = newVariant(self.godotObject) proc fromVariant*[T: NimGodotObject](self: var T, - val: Variant): ConversionResult = + val: Variant): ConversionResult = if val.getType() == VariantType.Object: let objPtr = val.asGodotObject() self = asNimGodotObject[T](objPtr) @@ -393,15 +421,25 @@ proc fromVariant*[T: NimGodotObject](self: var T, else: result = ConversionResult.TypeError -proc variantType*(T: typedesc[enum]): VariantType {.inline.} = - VariantType.Int +proc godotTypeInfo*(T: typedesc[enum]): GodotTypeInfo = + result = GodotTypeInfo( + variantType: VariantType.Int, + hint: GodotPropertyHint.Enum, + hintStr: "" + ) + for val in T: + if result.hintStr.len > 0: + result.hintStr.add(',') + result.hintStr.add($val) proc toVariant*[T: enum](self: T): Variant {.inline.} = newVariant(int64(ord(self))) proc fromVariant*[T: enum](self: var T, - val: Variant): ConversionResult {.inline.} = - if val.getType() == VariantType.Int: + val: Variant): ConversionResult {.inline.} = + if val.getType() == VariantType.Nil: + discard + elif val.getType() == VariantType.Int: self = T(val.asInt()) else: result = ConversionResult.TypeError @@ -410,73 +448,81 @@ proc toVariant*(self: Variant): Variant {.inline.} = self proc fromVariant*(self: var Variant, - val: Variant): ConversionResult {.inline.} = + val: Variant): ConversionResult {.inline.} = self = newVariant(val) -proc variantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} = - when T is SomeSignedInt or T is SomeUnsignedInt: - VariantType.Int - elif T is bool: - VariantType.Bool - elif T is SomeFloat: - VariantType.Real - elif T is string or T is GodotString: - VariantType.String - elif T is Vector2: - VariantType.Vector2 - elif T is Rect2: - VariantType.Rect2 - elif T is Vector3: - VariantType.Vector3 - elif T is Transform2D: - VariantType.Transform2D - elif T is Plane: - VariantType.Plane - elif T is Quat: - VariantType.Quat - elif T is Rect3: - VariantType.Rect3 - elif T is Basis: - VariantType.Basis - elif T is Transform: - VariantType.Transform - elif T is Color: - VariantType.Color - elif T is RID: - VariantType.RID - elif T is ptr GodotObject: - VariantType.Object - elif T is NodePath: - VariantType.NodePath - elif T is Dictionary: - VariantType.Dictionary - elif T is Array: - VariantType.Array - elif T is PoolByteArray: - VariantType.PoolByteArray - elif T is PoolIntArray: - VariantType.PoolIntArray - elif T is PoolRealArray: - VariantType.PoolRealArray - elif T is PoolStringArray: - VariantType.PoolStringArray - elif T is PoolVector2Array: - VariantType.PoolVector2Array - elif T is PoolVector3Array: - VariantType.PoolVector3Array - elif T is PoolColorArray: - VariantType.PoolColorArray - else: - VariantType.Nil +proc godotTypeInfo*(T: typedesc[SomeGodotOrNum]): GodotTypeInfo {.inline.} = + result.variantType = + when T is SomeSignedInt or T is SomeUnsignedInt: + VariantType.Int + elif T is bool: + VariantType.Bool + elif T is SomeFloat: + VariantType.Real + elif T is string or T is GodotString: + VariantType.String + elif T is Vector2: + VariantType.Vector2 + elif T is Rect2: + VariantType.Rect2 + elif T is Vector3: + VariantType.Vector3 + elif T is Transform2D: + VariantType.Transform2D + elif T is Plane: + VariantType.Plane + elif T is Quat: + VariantType.Quat + elif T is Rect3: + VariantType.Rect3 + elif T is Basis: + VariantType.Basis + elif T is Transform: + VariantType.Transform + elif T is Color: + VariantType.Color + elif T is RID: + VariantType.RID + elif T is ptr GodotObject: + VariantType.Object + elif T is NodePath: + VariantType.NodePath + elif T is Dictionary: + VariantType.Dictionary + elif T is Array: + VariantType.Array + elif T is PoolByteArray: + VariantType.PoolByteArray + elif T is PoolIntArray: + VariantType.PoolIntArray + elif T is PoolRealArray: + VariantType.PoolRealArray + elif T is PoolStringArray: + VariantType.PoolStringArray + elif T is PoolVector2Array: + VariantType.PoolVector2Array + elif T is PoolVector3Array: + VariantType.PoolVector3Array + elif T is PoolColorArray: + VariantType.PoolColorArray + else: + VariantType.Nil + +proc godotTypeInfo*(T: typedesc[range]): VariantType {.inline.} = + GodotTypeInfo( + variantType: VariantType.Int, + hint: GodotPropertyHint.Range, + hintStr: $low(T) & "," & $high(T) & ",1" + ) proc toVariant*[T: SomeGodotOrNum](val: T): Variant {.inline.} = newVariant(val) proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( self: var T, val: Variant): ConversionResult = - if val.getType() != VariantType.Int: - result = ConversionResult.TypeError - else: + if val.getType() == VariantType.Nil: + self = 0 + elif val.getType() == VariantType.Int: var intVal: (when T is SomeSignedInt: int64 else: uint64) intVal = when T is SomeSignedInt: val.asInt() @@ -485,9 +531,13 @@ proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( result = ConversionResult.RangeError else: self = T(intVal) + else: + result = ConversionResult.TypeError proc fromVariant*[T: SomeFloat](self: var T, val: Variant): ConversionResult = - if val.getType() == VariantType.Real: + if val.getType() == VariantType.Nil: + self = 0 + elif val.getType() == VariantType.Real: self = T(val.asReal()) elif val.getType() == VariantType.Int: self = T(val.asInt()) @@ -495,7 +545,10 @@ proc fromVariant*[T: SomeFloat](self: var T, val: Variant): ConversionResult = result = ConversionResult.TypeError proc fromVariant*[T: SomeGodot](self: var T, val: Variant): ConversionResult = - if variantType(T) != val.getType(): + if val.getType() == VariantType.Nil: + return + const typeInfo = godotTypeInfo(T) + if typeInfo.variantType != val.getType(): return ConversionResult.TypeError when self is bool: self = val.asBool() @@ -549,8 +602,8 @@ proc fromVariant*[T: SomeGodot](self: var T, val: Variant): ConversionResult = # mustn't reach this result = ConversionError.TypeError -proc variantType*(T: typedesc[string]): VariantType {.inline.} = - VariantType.String +proc godotTypeInfo*(T: typedesc[string]): GodotTypeInfo {.inline.} = + result.variantType = VariantType.String proc toVariant*(s: string): Variant {.inline.} = newVariant(s) @@ -563,61 +616,83 @@ proc fromVariant*(s: var string, val: Variant): ConversionResult = else: result = ConversionResult.TypeError -proc variantType*(T: typedesc[seq]): VariantType = - VariantType.Array +template arrTypeInfo(T) = + result.variantType = VariantType.Array + mixin godotTypeInfo + type ItemT = type(( + block: + var s: T; + when T is seq: s[0] else: s[low(s)])) + when compiles(godotTypeInfo(ItemT)): + let itemTypeInfo = godotTypeInfo(ItemT) + result.hintStr = $ord(itemTypeInfo.variantType) + result.hintStr.add('/') + result.hintStr.add($ord(itemTypeInfo.hint)) + result.hintStr.add(':') + if not itemTypeInfo.hintStr.isNil: + result.hintStr.add(itemTypeInfo.hintStr) -proc variantType*(T: typedesc[array]): VariantType = - VariantType.Array +proc godotTypeInfo*(T: typedesc[seq]): GodotTypeInfo = + arrTypeInfo(T) + +proc godotTypeInfo*(T: typedesc[array]): GodotTypeInfo = + arrTypeInfo(T) proc toVariant*[T](s: openarray[T]): Variant = var arr = newArray() - mixin toGodot + mixin toVariant for item in s: arr.add(toVariant(item)) result = newVariant(arr) proc fromVariant*[T](s: var seq[T], val: Variant): ConversionResult = - if val.getType() != VariantType.Array: - result = ConversionResult.TypeError - else: + if val.getType() == VariantType.Nil: + s = nil + elif val.getType() == VariantType.Array: let arr = val.asArray() s = newSeq[T](arr.len) for idx, item in arr: - mixin fromGodot + mixin fromVariant let convResult = fromVariant(s[idx], item) if convResult != ConversionResult.OK: s = nil return convResult + else: + result = ConversionResult.TypeError proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult = - if val.getType() != VariantType.Array: - result = ConversionResult.TypeError - else: + if val.getType() == VariantType.Nil: + discard + elif val.getType() == VariantType.Array: let arr = val.asArray() if s.len != arr.len: return ConversionResult.TypeError for idx, item in arr: - mixin fromGodot + mixin fromVariant let convResult = fromVariant(s[idx], item) if convResult != ConversionResult.OK: return convResult + else: + result = ConversionResult.TypeError -proc variantType*(T: typedesc[Table|TableRef]): VariantType {.inline.} = - VariantType.Dictionary +proc godotTypeInfo*(T: typedesc[Table|TableRef]): GodotTypeInfo {.inline.} = + result.variantType = VariantType.Dictionary proc toVariant*[T: Table or TableRef](t: T): Variant = var dict = newDictionary() - mixin toGodot + mixin toVariant for k, v in t.pairs(): dict[toVariant(k)] = toVariant(v) result = newVariant(dict) -proc fromVariant*[T: Table or TableRef](t: var T, val: Variant): ConversionResult = - if val.getType() != VariantType.Dictionary: - result = ConversionResult.TypeError - else: +proc fromVariant*[T: Table or TableRef](t: var T, + val: Variant): ConversionResult = + if val.getType() == VariantType.Nil: + when t is ref: + t = nil + elif val.getType() == VariantType.Dictionary: let dict = val.asDictionary() - mixin fromGodot + mixin fromVariant when t is Table: t = initTable[type(t.keys()), type(t.values())]() else: @@ -636,6 +711,8 @@ proc fromVariant*[T: Table or TableRef](t: var T, val: Variant): ConversionResul t = nil return valResult t[nimKey] = nimVal + else: + result = ConversionResult.TypeError {.emit: """/*TYPESECTION*/ void NimMain(void); From 3b89eeb9a7155dad288d5bc9a02a3eec80e859fe Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 5 Aug 2017 22:33:21 +0700 Subject: [PATCH 046/160] Support default values --- godot/nim/godotmacros.nim | 38 +++++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index b081d9d..a8c4741 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -394,7 +394,7 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, var hintStrGodot = hintStr.toGodotString() {.push warning[ProveInit]: off.} # false warning, Nim bug - let attr = GodotPropertyAttributes( + var attr = GodotPropertyAttributes( typ: ord(variantType), hint: hint, hintString: hintStrGodot, @@ -422,7 +422,7 @@ proc toGodotStyle(s: string): string {.compileTime.} = proc genType(obj: ObjectDecl): NimNode {.compileTime.} = result = newNimNode(nnkStmtList) - # 1. Nim type definition + # Nim type definition let typeDef = newNimNode(nnkTypeDef) result.add(newNimNode(nnkTypeSection).add(typeDef)) typeDef.add(postfix(ident(obj.name), "*")) @@ -437,20 +437,40 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = let recList = newNimNode(nnkRecList) objTy.add(recList) + let initBody = newStmtList() for decl in obj.fields: if not decl.defaultValue.isNil and decl.defaultValue.kind != nnkEmpty: - parseError(decl.defaultValue, - "Default values are not supported for fields for now.") + initBody.add(newNimNode(nnkAsgn).add(decl.name, decl.defaultValue)) let name = if not decl.isExported: decl.name else: postfix(decl.name, "*") recList.add(newIdentDefs(name, decl.typ)) - # 2. {.this: self.} for convenience + # Add default values to init method + if initBody.len > 0: + var initMethod: NimNode + for meth in obj.methods: + if meth.name == "init" and meth.nimNode[3].len == 1: + initMethod = meth.nimNode + break + if initMethod.isNil: + obj.methods.add(MethodDecl( + name: "init", + args: newSeq[VarDecl](), + returnType: newEmptyNode(), + isVirtual: true, + isNoGodot: false, + nimNode: newProc(ident("init"), body = initBody, + procType = nnkMethodDef) + )) + else: + initMethod.body.insert(0, initBody) + + # {.this: self.} for convenience result.add(newNimNode(nnkPragma).add(newNimNode(nnkExprColonExpr).add( ident("this"), ident("self") ))) - # 3. Nim proc defintions + # Nim proc defintions var decls = newSeqOfCap[NimNode](obj.methods.len) for meth in obj.methods: let selfArg = newIdentDefs(ident("self"), ident(obj.name)) @@ -467,7 +487,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = for meth in obj.methods: result.add(meth.nimNode) - # 4. Register Godot object + # Register Godot object let parentName = if obj.parentName.isNil: newStrLitNode("Object") else: newStrLitNode(obj.parentName) let classNameLit = newCStringLit(obj.name) @@ -478,7 +498,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = registerGodotClass(classNameIdent, classNameLit, isRef, parentName, genSym(nskProc, "createFunc"), obj.isTool))) - # 5. Register fields (properties) + # Register fields (properties) for field in obj.fields: if field.isNoGodot: continue let hintStr = if field.hintStr.isNil: "NIM" @@ -501,7 +521,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = newStrLitNode(hintStr), hintIdent, usageIdent, ident($hasDefaultValue), field.defaultValue))) - # 6. Register methods + # Register methods template registerGodotMethod(classNameLit, classNameIdent, methodNameIdent, methodNameLit, minArgs, maxArgs, argTypes, methFuncIdent, hasReturnValue) = From 64a8aefeb811c2716870dda740d3028e12669817 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 5 Aug 2017 22:33:51 +0700 Subject: [PATCH 047/160] Delete nimruntime --- godot/nimruntime.nim | 23 ----------------------- 1 file changed, 23 deletions(-) delete mode 100644 godot/nimruntime.nim diff --git a/godot/nimruntime.nim b/godot/nimruntime.nim deleted file mode 100644 index 475785f..0000000 --- a/godot/nimruntime.nim +++ /dev/null @@ -1,23 +0,0 @@ -# Copyright 2017 Xored Software, Inc. - -import asyncdispatch -import godot, node - -{.warning: ("NimRuntime is deprecated - it is no longer necessary to add it " & - "as an AutoLoad class. It will be removed in v0.5.0.").} - -gdobj NimRuntime of Node: - method enterTree*() = - discard getTree().connect("idle_frame", self, "idle", newArray()) - - method exitTree*() = - getTree().disconnect("idle_frame", self, "idle") - - proc idle*() {.gdExport.} = - if asyncdispatch.hasPendingOperations(): - poll(0) - GC_step(2000, false, 0) - -when not defined(release): - onUnhandledException = proc(errorMsg: string) = - printError("Unhandled Nim exception: " & errorMsg) From fd40716b581f55e0c0cd6a913d35439bb416bde5 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 5 Aug 2017 22:55:27 +0700 Subject: [PATCH 048/160] print can be used similar to echo --- godot/nim/godotnim.nim | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 01f5b55..bab3dd1 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -89,15 +89,12 @@ template printError*(error: typed) = let (filename, line) = instantiationInfo() godotPrintError(cstring($error), nil, cstring(filename), line.cint) -proc print*(message: string) {.inline.} = - ## Prints ``message`` to Godot log. - var s = message.toGodotString() - godotPrint(s) - s.deinit() - -proc print*(message: cstring) {.inline.} = - ## Prints ``message`` to Godot log. - var s = message.toGodotString() +proc print*(parts: varargs[string, `$`]) = + ## Prints concatenated ``parts`` to Godot log. + var combined = "" + for v in parts: + combined.add(v) + var s = combined.toGodotString() godotPrint(s) s.deinit() From f91a0d0364ffa6d7c210c17ef10cc02ab4e6a880 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 5 Aug 2017 23:02:48 +0700 Subject: [PATCH 049/160] Allow gdExport without Nim export --- godot/nim/godotmacros.nim | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index a8c4741..9574b4c 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -125,10 +125,6 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = let hintStr = removeStrPragma(nameNode, "hintStr") let usage = removeStrPragma(nameNode, "usage") let isGdExport = removePragma(nameNode, "gdExport") - if not nameNode.isExported() and isGdExport: - parseError(nameNode, "gdExport is not applicable for private fields") - - let isNoGodot = not nameNode.isExported() or not isGdExport result.add(VarDecl( name: if nameNode.kind == nnkPragmaExpr: nameNode[0].basename() @@ -137,21 +133,16 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = defaultValue: identDefs[identDefs.len - 1], hint: hint, hintStr: hintStr, - isNoGodot: isNoGodot, + isNoGodot: not isGdExport, usage: usage, isExported: nameNode.isExported() )) proc parseMethod(meth: NimNode): MethodDecl = assert(meth.kind in {nnkProcDef, nnkMethodDef}) - let methName = meth[0] let isGdExport = removePragma(meth, "gdExport") - if not methName.isExported() and isGdExport: - parseError(meth, "gdExport is not applicable for private procs/methods") - let isNoGodot = meth.kind != nnkMethodDef and ( - not methName.isExported() or - not isGdExport - ) or removePragma(meth, "noExport") + let isNoGodot = (meth.kind != nnkMethodDef and not isGdExport) or + removePragma(meth, "noExport") result = MethodDecl( name: $meth[0].basename, args: newSeq[VarDecl](), From 72b706d7fea4a7381e5fe52eb3c9363f096cde50 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sun, 6 Aug 2017 13:43:11 +0700 Subject: [PATCH 050/160] Allow to omit type when default value is present --- godot/nim/godotmacros.nim | 14 +++++++++++--- godot/nim/godotnim.nim | 6 ++++-- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 9574b4c..32e861d 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -119,6 +119,12 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = assert(identDefs.kind == nnkIdentDefs) result = newSeqOfCap[VarDecl](identDefs.len - 2) + var typ = identDefs[identDefs.len - 2] + if typ.kind == nnkEmpty: + let defaultValue = identDefs[identDefs.len - 1] + if defaultValue.kind != nnkEmpty: + typ = newCall("type", defaultValue) + for i in 0..<(identDefs.len - 2): let nameNode = identDefs[i].copyNimTree() let hint = removeStrPragma(nameNode, "hint") @@ -129,7 +135,7 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = result.add(VarDecl( name: if nameNode.kind == nnkPragmaExpr: nameNode[0].basename() else: nameNode.basename(), - typ: identDefs[identDefs.len - 2], + typ: typ, defaultValue: identDefs[identDefs.len - 1], hint: hint, hintStr: hintStr, @@ -273,13 +279,13 @@ macro invokeVarArgs(procIdent, objIdent; proc typeError(nimType: string, value: string, godotType: VariantType, className: cstring, propertyName: cstring): string = result = "Tried to assign incompatible value " & value & " (" & $godotType & - ") to field \"" & $propertyName & "\" (" & $nimType & ") of " & + ") to field \"" & $propertyName & ": " & $nimType & "\" of " & $className proc rangeError(nimType: string, value: string, className: cstring, propertyName: cstring): string = result = "Tried to assign the out-of-range value " & value & - " to field \"" & $propertyName & "\" (" & $nimType & ") of " & + " to field \"" & $propertyName & ": " & $nimType & "\" of " & $className @@ -637,5 +643,7 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = ## that you can find in `Godot API `_. let typeDef = parseType(definition, callsite()) result = genType(typeDef) + if typeDef.name == "MyObj": + echo repr result {.push warning[Deprecated]: on.} diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index bab3dd1..c199216 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -664,11 +664,13 @@ proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult = let arr = val.asArray() if s.len != arr.len: return ConversionResult.TypeError - for idx, item in arr: + var nimIdx = low(s) # may not start from 0 and may even be an enum + for item in arr: mixin fromVariant - let convResult = fromVariant(s[idx], item) + let convResult = fromVariant(s[nimIdx], item) if convResult != ConversionResult.OK: return convResult + inc nimIdx else: result = ConversionResult.TypeError From 6aaeed4dca6e193cce96b0a3a70647aa48fb835b Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sun, 6 Aug 2017 13:58:54 +0700 Subject: [PATCH 051/160] Add missing $ to standard types --- godot/core/arrays.nim | 15 +++++++----- godot/core/dictionaries.nim | 11 +++++++++ godot/core/rids.nim | 3 +++ godot/core/variants.nim | 7 +++--- godot/internal/godotarrays.nim | 41 ++++++++++++++++++++------------ godot/internal/godotvariants.nim | 5 ++++ 6 files changed, 58 insertions(+), 24 deletions(-) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 58c3942..5157e50 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -134,10 +134,13 @@ proc len*(self: Array): int {.inline.} = proc sort*(self: var Array) {.inline.} = self.godotArray.sort() -iterator items*(arr: Array): Variant = - for i in 0.. 1: + result.add(", ") + result.add($k) + result.add(": ") + result.add($v) + result.add('}') diff --git a/godot/core/rids.nim b/godot/core/rids.nim index aece8c5..6ec5b86 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -22,6 +22,9 @@ proc idCInt(self: RID): cint {. proc id*(self: RID): uint32 {.inline.} = cast[uint32](self.idCInt()) +proc `$`*(self: RID): string = + $self.id + proc `==`*(a, b: RID): bool {. importc: "godot_rid_operator_equal".} proc `<`*(a, b: RID): bool {. diff --git a/godot/core/variants.nim b/godot/core/variants.nim index 6e875c3..1f0d752 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -27,6 +27,9 @@ proc variantFinalizer*(v: Variant) = if not v.noDeinit: v.godotVariant.deinit() +proc `$`*(self: Variant): string {.inline.} = + $self.godotVariant + proc newVariant*(): Variant {.inline.} = new(result, variantFinalizer) initGodotVariant(result.godotVariant) @@ -174,9 +177,7 @@ proc asReal*(self: Variant): cdouble = self.godotVariant.asReal() proc asString*(self: Variant): string = - var s = self.godotVariant.asGodotString() - result = $s - s.deinit() + $self proc asVector2*(self: Variant): Vector2 = self.godotVariant.asVector2() diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index ac53bfb..d6ee910 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -4,6 +4,10 @@ type GodotArray* {.byref.} = object data: array[sizeof(int), byte] +proc len*(self: GodotArray): cint {. + noSideEffect, + importc: "godot_array_size".} + import hashes import godotobjects, godotpoolarrays, godotvariants, godotstrings @@ -94,26 +98,33 @@ proc rfind*(self: GodotArray; what: GodotVariant; f: cint): cint {. noSideEffect, importc: "godot_array_rfind".} -proc len*(self: GodotArray): cint {. - noSideEffect, - importc: "godot_array_size".} proc sort*(self: var GodotArray) {.importc: "godot_array_sort".} proc sortCustom*(self: var GodotArray; obj: var GodotObject; funcName: GodotString) {. importc: "godot_array_sort_custom".} -iterator items*(arr: GodotArray): GodotVariant = - for i in 0.. 1: + result.add(", ") + result.add($item) + result.add(']') diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 81ce797..388c4b3 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -191,3 +191,8 @@ proc hashCompare*(self, other: GodotVariant): bool {. importc: "godot_variant_hash_compare".} proc booleanize*(self: GodotVariant; isValid: var bool): bool {. importc: "godot_variant_booleanize".} + +proc `$`*(self: GodotVariant): string = + var s = self.asGodotString() + result = $s + s.deinit() From 6549d90c3ba9205305b2d1ed7ce9ee1ebca626b9 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sun, 6 Aug 2017 13:59:33 +0700 Subject: [PATCH 052/160] Remove commented code from poolarrays --- godot/core/poolarrays.nim | 58 --------------------------------------- 1 file changed, 58 deletions(-) diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 78aaf6d..bb263d2 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -3,64 +3,6 @@ import vector2, vector3, colors import internal.godotpoolarrays, internal.godotstrings -# type -# PoolByteArray* = ref object -# godotPoolByteArray: GodotPoolByteArray -# PoolIntArray* = ref object -# godotPoolIntArray: GodotPoolIntArray -# PoolRealArray* = ref object -# godotPoolRealArray: GodotPoolRealArray -# PoolVector2Array* = ref object -# godotPoolVector2Array: GodotPoolVector2Array -# PoolVector3Array* = ref object -# godotPoolVector3Array: GodotPoolVector3Array -# PoolColorArray* = ref object -# godotPoolColorArray: GodotPoolColorArray -# PoolStringArray* = ref object -# godotPoolStringArray: GodotPoolStringArray - -# proc godotPoolByteArray*(self: PoolByteArray): -# ptr GodotPoolByteArray {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolByteArray - -# proc godotPoolIntArray*(self: PoolIntArray): -# ptr GodotPoolIntArray {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolIntArray - -# proc godotPoolRealArray*(self: PoolRealArray): -# ptr GodotPoolRealArray {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolRealArray - -# proc godotPoolVector2Array*(self: PoolVector2Array): -# ptr GodotPoolVector2Array {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolVector2Array - -# proc godotPoolVector3Array*(self: PoolVector3Array): -# ptr GodotPoolVector3Array {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolVector3Array - -# proc godotPoolColorArray*(self: PoolColorArray): -# ptr GodotPoolColorArray {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolColorArray - -# proc godotPoolStringArray*(self: PoolStringArray): -# ptr GodotPoolStringArray {.inline.} = -# ## WARNING: do not keep the returned value for longer than the lifetime of -# ## the array. -# addr self.godotPoolStringArray - template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, initProcName) = type From 643c445f87f876fefaadb6b2f225cb92314585e1 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sun, 6 Aug 2017 14:21:48 +0700 Subject: [PATCH 053/160] Allow conversion from Real to int types --- godot/nim/godotnim.nim | 60 ++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 31 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index c199216..b40d883 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -418,29 +418,6 @@ proc fromVariant*[T: NimGodotObject](self: var T, else: result = ConversionResult.TypeError -proc godotTypeInfo*(T: typedesc[enum]): GodotTypeInfo = - result = GodotTypeInfo( - variantType: VariantType.Int, - hint: GodotPropertyHint.Enum, - hintStr: "" - ) - for val in T: - if result.hintStr.len > 0: - result.hintStr.add(',') - result.hintStr.add($val) - -proc toVariant*[T: enum](self: T): Variant {.inline.} = - newVariant(int64(ord(self))) - -proc fromVariant*[T: enum](self: var T, - val: Variant): ConversionResult {.inline.} = - if val.getType() == VariantType.Nil: - discard - elif val.getType() == VariantType.Int: - self = T(val.asInt()) - else: - result = ConversionResult.TypeError - proc toVariant*(self: Variant): Variant {.inline.} = self @@ -519,7 +496,8 @@ proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( self: var T, val: Variant): ConversionResult = if val.getType() == VariantType.Nil: self = 0 - elif val.getType() == VariantType.Int: + elif val.getType() == VariantType.Int or val.getType() == VariantType.Real: + # Real is allowed, because that's what the editor sets for Int values var intVal: (when T is SomeSignedInt: int64 else: uint64) intVal = when T is SomeSignedInt: val.asInt() @@ -531,13 +509,32 @@ proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( else: result = ConversionResult.TypeError +proc godotTypeInfo*(T: typedesc[enum]): GodotTypeInfo = + result = GodotTypeInfo( + variantType: VariantType.Int, + hint: GodotPropertyHint.Enum, + hintStr: "" + ) + for val in T: + if result.hintStr.len > 0: + result.hintStr.add(',') + result.hintStr.add($val) + +proc toVariant*[T: enum](self: T): Variant {.inline.} = + newVariant(int64(ord(self))) + +proc fromVariant*[T: enum](self: var T, + val: Variant): ConversionResult {.inline.} = + var intConv: int64 + result = fromVariant(intConv, val) + if result == ConversionResult.OK: + self = T(intConv) + proc fromVariant*[T: SomeFloat](self: var T, val: Variant): ConversionResult = if val.getType() == VariantType.Nil: self = 0 - elif val.getType() == VariantType.Real: + elif val.getType() == VariantType.Real or val.getType() == VariantType.Int: self = T(val.asReal()) - elif val.getType() == VariantType.Int: - self = T(val.asInt()) else: result = ConversionResult.TypeError @@ -647,13 +644,13 @@ proc fromVariant*[T](s: var seq[T], val: Variant): ConversionResult = s = nil elif val.getType() == VariantType.Array: let arr = val.asArray() - s = newSeq[T](arr.len) + var newS = newSeq[T](arr.len) for idx, item in arr: mixin fromVariant - let convResult = fromVariant(s[idx], item) + let convResult = fromVariant(newS[idx], item) if convResult != ConversionResult.OK: - s = nil return convResult + shallowCopy(s, newS) else: result = ConversionResult.TypeError @@ -670,7 +667,8 @@ proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult = let convResult = fromVariant(s[nimIdx], item) if convResult != ConversionResult.OK: return convResult - inc nimIdx + if nimIdx != high(s): + inc nimIdx else: result = ConversionResult.TypeError From 327cd0e18fa5112909daa5f2b7d73565c46a1b0a Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sun, 6 Aug 2017 18:59:22 +0700 Subject: [PATCH 054/160] Proper inheritance checks and conversion --- godot/nim/godotmacros.nim | 18 +++++---- godot/nim/godotnim.nim | 78 +++++++++++++++++++++++++++------------ 2 files changed, 64 insertions(+), 32 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 32e861d..326465f 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -41,9 +41,9 @@ proc nimToGodot[T](val: T): Variant = when compiles(toVariant(val)): result = toVariant(val) else: - printError("Failed to convert Nim value of type " & T.name & - " into Variant") - initNilVariant(result) + const err = "Cannot convert Nim value of type " & T.name & + " into Variant" + {.error: err.} template parseError(node: NimNode, msg: string) = raise newException(ParseError, lineinfo(node) & ": " & msg) @@ -62,9 +62,10 @@ proc extractNames(definition: NimNode): else: parseError(definition[2], "parent type expected") -proc newRStrLit(s: string): NimNode {.compileTime.} = - result = newNimNode(nnkRStrLit) - result.strVal = s +when not declared(newRStrLit): + proc newRStrLit(s: string): NimNode {.compileTime.} = + result = newNimNode(nnkRStrLit) + result.strVal = s proc newCStringLit(s: string): NimNode {.compileTime.} = newNimNode(nnkCallStrLit).add(ident("cstring"), newRStrLit(s)) @@ -318,9 +319,10 @@ template registerGodotClass(classNameIdent, classNameLit, isRef, baseNameLit, createFuncIdent; isTool: bool) = proc createFuncIdent(obj: ptr GodotObject, methData: pointer): pointer {.noconv.} = - let nimObj = new(classNameIdent) - nimObj.setOwn() + var nimObj: classNameIdent + new(nimObj, nimGodotObjectFinalizer[classNameIdent]) nimObj.setGodotObject(obj) + nimObj.setNativeObject(asNimGodotObject[NimGodotObject](obj, noRef = true)) GC_ref(nimObj) result = cast[pointer](nimObj) when compiles(nimObj.init()): diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index b40d883..b9eafa3 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -28,10 +28,17 @@ import godotinternal type NimGodotObject* = ref object of RootObj ## The base type all Godot types inherit from. - ## Manages lifecycle of the wrapped GodotObject. + ## Manages lifecycle of the wrapped ``GodotObject``. godotObject: ptr GodotObject + linkedObject: NimGodotObject + ## Wrapper around native object that is the container of the Nim "script" + ## This is needed for `of` checks and `as` conversions to work as + ## expected. For example, Nim type may inherit from ``Spatial``, but the + ## script is attached to ``Particles``. In this case conversion to + ## ``Particles`` is valid, but Nim type system is not aware of that. + ## This works in both directions - for linked native object this + ## reference points to Nim object. isExternalRef: bool - isOwn: bool ConversionResult* {.pure.} = enum ## Conversion result to return from ``fromVariant`` procedure. @@ -133,12 +140,14 @@ proc deinit*(obj: NimGodotObject) = assert(not obj.godotObject.isNil) obj.godotObject.deinit() obj.godotObject = nil + # linked object internal pointer should be unset from destructor + assert(obj.linkedObject.isNil or obj.linkedObject.godotObject.isNil) -proc godotFinalizer[T: NimGodotObject](obj: T) = +proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) = if obj.godotObject.isNil: return if obj.isExternalRef and obj.godotObject.unreference(): obj.deinit() - elif obj.isOwn: + elif not obj.linkedObject.isNil: obj.deinit() macro baseNativeType(T: typedesc): cstring = @@ -181,7 +190,7 @@ template registerClass*(T: typedesc; godotClassName: cstring, classRegistry = newTable[cstring, ObjectInfo]() let constructor = proc(): NimGodotObject = var t: T - new(t, godotFinalizer[T]) + new(t, nimGodotObjectFinalizer[T]) result = t const base = baseNativeType(T) @@ -208,7 +217,7 @@ template registerClass*(T: typedesc; godotClassName: cstring, nativeClasses.add(T.name) proc newNimGodotObject[T: NimGodotObject]( - godotObject: ptr GodotObject, godotClassName: cstring): T = + godotObject: ptr GodotObject, godotClassName: cstring, noRef: bool): T = assert(not classRegistry.isNil) assert(not godotObject.isNil) let objInfo = classRegistry.getOrDefault(godotClassName) @@ -217,11 +226,12 @@ proc newNimGodotObject[T: NimGodotObject]( else: result = T(objInfo.constructor()) result.godotObject = godotObject - if objInfo.isRef: + if not noRef and objInfo.isRef: result.isExternalRef = true result.godotObject.reference() -proc asNimGodotObject*[T: NimGodotObject](godotObject: ptr GodotObject): T = +proc asNimGodotObject*[T: NimGodotObject]( + godotObject: ptr GodotObject, noRef: bool = false): T = ## Wraps ``godotObject`` into Nim type ``T``. ## This is used by `godotapigen `_ and should rarely be ## used by anything else. @@ -234,7 +244,7 @@ proc asNimGodotObject*[T: NimGodotObject](godotObject: ptr GodotObject): T = result = nil if result.isNil: result = newNimGodotObject[T]( - godotObject, cstring(godotObject.getClassName())) + godotObject, cstring(godotObject.getClassName()), noRef) proc newVariant*(obj: NimGodotObject): Variant {.inline.} = newVariant(obj.godotObject) @@ -258,14 +268,27 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = ## ## This can be used either in dot notation (``node.as(Button)``) or ## infix notation (``node as Button``). - if obj.isNil or not (obj of T): - when not defined(release): - if not obj.isNil: - printError("Failed to cast object to " & - t.name & "\n" & getStackTrace()) - result = nil - else: + if obj.isNil: return nil + if obj of T: result = T(obj) + elif not obj.linkedObject.isNil and obj.linkedObject of T: + result = T(obj.linkedObject) + else: + when not defined(release): + printError("Failed to cast object to " & + T.name & "\n" & getStackTrace()) + result = nil + +proc `~`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): bool = + ## Godot-specific inheritance check. You must use this over Nim's standard + ## ``of`` operator, because Nim does not know which object your script is + ## attached to in runtime. For example, if you create a + ## ``gdobj Bullet of Spatial`` and the ``Bullet`` is attached to a + ## ``MeshInstance``, ``myBullet of MeshInstance`` will return ``false``, but + ## ``myBullet ~ MeshInstance`` will return ``true``. + ## This is going to be changed to ``of`` in later versions, when Nim starts + ## supporting overloading ``of`` operator. + obj of T or obj.linkedObject of T proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) @@ -378,21 +401,28 @@ proc newConversionError*(err: ConversionResult): ref ValueError = result = newException(ValueError, msg) proc setGodotObject*(nimObj: NimGodotObject, obj: ptr GodotObject) {.inline.} = - ## Used from Godot constructor. Don't call this. + ## Used from Godot constructor produced by ``gdobj`` macro. Do not call. assert(not obj.isNil) assert(nimObj.godotObject.isNil) # reassignment is not allowed nimObj.godotObject = obj -proc setOwn*(nimObj: NimGodotObject) {.inline.} = - ## Used from Godot constructor. Don't call this. - nimObj.isOwn = true +proc setNativeObject*(nimObj: NimGodotObject, + nativeObj: NimGodotObject) {.inline.} = + ## Used from Godot constructor produced by ``gdobj`` macro. Do not call. + nimObj.linkedObject = nativeObj + nativeObj.linkedObject = nimObj proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} = - ## Used from Godot destructor. Don't call this. + ## Used from Godot destructor produced by ``gdobj`` macro. Do not call. nimObj.godotObject = nil + nimObj.linkedObject.godotObject = nil + +proc `==`*(self, other: NimGodotObject): bool {.inline.} = + ## Compares objects by referential equality. + self.godotObject == other.godotObject proc godotObject*(nimObj: NimGodotObject): ptr GodotObject {.inline.} = - ## Returns internal poitner to ``GodotObject``. Use only if you know what + ## Returns raw poitner to ``GodotObject``. Use only if you know what ## you are doing. nimObj.godotObject @@ -719,7 +749,7 @@ N_NOINLINE(void, setStackBottom)(void* thestackbottom); var nativeLibHandle: pointer proc getNativeLibHandle*(): pointer = ## Returns NativeScript library handle used to register type information - ## in Godot. Use only if you know what you are doing. + ## in Godot. return nativeLibHandle proc godot_nativescript_init(handle: pointer) {. @@ -746,7 +776,7 @@ const nimGcStepLengthUs {.intdefine.} = 2000 proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = if asyncdispatch.hasPendingOperations(): poll(0) - GC_step(nimGcStepLengthUs, false, 0) + GC_step(nimGcStepLengthUs, true, 0) when not defined(release): onUnhandledException = proc(errorMsg: string) = From 8ef554501fb9578a1af50e42050a557b9c8b8286 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 7 Aug 2017 20:59:32 +0700 Subject: [PATCH 055/160] Add nil check to tilde --- godot/nim/godotnim.nim | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index b9eafa3..f8893d5 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -279,7 +279,8 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = T.name & "\n" & getStackTrace()) result = nil -proc `~`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): bool = +proc `~`*[T: NimGodotObject](obj: NimGodotObject, + t: typedesc[T]): bool {.inline.} = ## Godot-specific inheritance check. You must use this over Nim's standard ## ``of`` operator, because Nim does not know which object your script is ## attached to in runtime. For example, if you create a @@ -288,7 +289,7 @@ proc `~`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): bool = ## ``myBullet ~ MeshInstance`` will return ``true``. ## This is going to be changed to ``of`` in later versions, when Nim starts ## supporting overloading ``of`` operator. - obj of T or obj.linkedObject of T + not obj.isNil and (obj of T or obj.linkedObject of T) proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) From 4cc9711d2f187d3be10da4b2ff9f62bc6c84a0ad Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 7 Aug 2017 22:13:42 +0700 Subject: [PATCH 056/160] Handle nil in == --- godot/nim/godotnim.nim | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index f8893d5..90c40e5 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -420,7 +420,9 @@ proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} = proc `==`*(self, other: NimGodotObject): bool {.inline.} = ## Compares objects by referential equality. - self.godotObject == other.godotObject + if self.isNil and other.isNil: return true + if self.isNil != other.isNil: return false + result = (self.godotObject == other.godotObject) proc godotObject*(nimObj: NimGodotObject): ptr GodotObject {.inline.} = ## Returns raw poitner to ``GodotObject``. Use only if you know what From daa56270e5cbb320a389b04e327a75237e4db1f1 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 8 Aug 2017 17:23:45 +0700 Subject: [PATCH 057/160] Fix object property export --- godot/godot.nim | 2 +- godot/godotinternal.nim | 6 ++--- godot/nim/godotmacros.nim | 55 +++++++++++++++++++++++---------------- godot/nim/godotnim.nim | 36 +++++++++++++++---------- 4 files changed, 58 insertions(+), 41 deletions(-) diff --git a/godot/godot.nim b/godot/godot.nim index 3514ea2..eb38a58 100644 --- a/godot/godot.nim +++ b/godot/godot.nim @@ -14,4 +14,4 @@ export godotbase, vector2, rect2, vector3, transform2d, planes, quats, poolarrays, variants export godotmacros, godotnim -export GodotPropertyHint, GodotPropertyUsageFlags \ No newline at end of file +export GodotPropertyHint, GodotPropertyUsage \ No newline at end of file diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index 754900a..fe253dc 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -118,7 +118,7 @@ const GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE type - GodotPropertyUsageFlags* {.size: sizeof(cint), pure.} = enum + GodotPropertyUsage* {.size: sizeof(cint), pure.} = enum Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE @@ -151,7 +151,7 @@ type typ*: cint hint*: GodotPropertyHint hintString*: GodotString - usage*: GodotPropertyUsageFlags + usage*: cint defaultValue*: GodotVariant GodotInstanceCreateFunc* {.bycopy.} = object @@ -217,7 +217,7 @@ type typ*: cint hint*: GodotPropertyHint hintString*: GodotString - usage*: GodotPropertyUsageFlags + usage*: cint defaultValue*: GodotVariant GodotSignal* = object diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 326465f..c96b164 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -12,7 +12,7 @@ type isNoGodot: bool hint: string hintStr: string - usage: string + usage: NimNode isExported: bool MethodDecl = ref object @@ -71,15 +71,31 @@ proc newCStringLit(s: string): NimNode {.compileTime.} = newNimNode(nnkCallStrLit).add(ident("cstring"), newRStrLit(s)) iterator pragmas(node: NimNode): - tuple[key: NimIdent, value: string, index: int] = + tuple[key: NimIdent, value: NimNode, index: int] = assert node.kind in {nnkPragma, nnkEmpty} for index in countdown(node.len - 1, 0): if node[index].kind == nnkExprColonExpr: - let val = $(node[index][1]) - yield (node[index][0].ident, val, index) + yield (node[index][0].ident, node[index][1], index) elif node[index].kind == nnkIdent: yield (node[index].ident, nil, index) +proc removePragmaNode(statement: NimNode, + pname: string): NimNode {.compileTime.} = + ## Removes the pragma from the node and returns value of the pragma + ## Works for routine nodes or nnkPragmaExpr + if not (RoutineNodes.contains(statement.kind) or + statement.kind == nnkPragmaExpr): + return nil + + result = nil + var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma() + else: statement[1] + let pnameIdent = !pname + for ident, val, i in pragmas(pragmas): + if ident == pnameIdent: + pragmas.del(i) + return val + proc removePragma(statement: NimNode, pname: string): bool = ## Removes the pragma from the node and returns whether pragma was removed if not (RoutineNodes.contains(statement.kind) or @@ -97,18 +113,9 @@ proc removeStrPragma(statement: NimNode, pname: string): string {.compileTime.} = ## Removes the pragma from the node and returns value of the pragma ## Works for routine nodes or nnkPragmaExpr - if not (RoutineNodes.contains(statement.kind) or - statement.kind == nnkPragmaExpr): - return nil - - result = nil - var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma() - else: statement[1] - let pnameIdent = !pname - for ident, val, i in pragmas(pragmas): - if ident == pnameIdent: - pragmas.del(i) - return (if val.isNil: "" else: val) + let node = removePragmaNode(statement, pname) + result = if node.isNil: nil + else: $node proc isExported(node: NimNode): bool {.compileTime.} = if node.kind == nnkPragmaExpr: @@ -130,7 +137,7 @@ proc identDefsToVarDecls(identDefs: NimNode): seq[VarDecl] = let nameNode = identDefs[i].copyNimTree() let hint = removeStrPragma(nameNode, "hint") let hintStr = removeStrPragma(nameNode, "hintStr") - let usage = removeStrPragma(nameNode, "usage") + let usage = removePragmaNode(nameNode, "usage") let isGdExport = removePragma(nameNode, "gdExport") result.add(VarDecl( @@ -345,7 +352,7 @@ template registerGodotClass(classNameIdent, classNameLit, isRef, template registerGodotField(classNameLit, classNameIdent, propNameLit, propNameIdent, propTypeLit, propTypeIdent, setFuncIdent, getFuncIdent, hintStrLit, - hintIdent, usageIdent, hasDefaultValue, + hintIdent, usageExpr, hasDefaultValue, defaultValueNode) = proc setFuncIdent(obj: ptr GodotObject, methData: pointer, nimPtr: pointer, val: GodotVariant) {.noconv.} = @@ -397,7 +404,7 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, typ: ord(variantType), hint: hint, hintString: hintStrGodot, - usage: GodotPropertyUsageFlags.usageIdent + usage: usageExpr ) {.push warning[ProveInit]: on.} when hasDefaultValue: @@ -504,12 +511,14 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = else: field.hintStr let hint = if field.hint.isNil: "NIM" else: field.hint - let usage = if field.usage.isNil: "Default" - else: field.usage + let usage = + if field.usage.isNil: + newLit(ord(GodotPropertyUsage.Default) or + ord(GodotPropertyUsage.ScriptVariable)) + else: field.usage let hasDefaultValue = not field.defaultValue.isNil and field.defaultValue.kind != nnkEmpty let hintIdent = ident(hint) - let usageIdent = ident(usage) let nimType = repr field.typ result.add(getAst( registerGodotField(classNameLit, classNameIdent, @@ -517,7 +526,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = ident(field.name), nimType, field.typ, genSym(nskProc, "setFunc"), genSym(nskProc, "getFunc"), - newStrLitNode(hintStr), hintIdent, usageIdent, + newStrLitNode(hintStr), hintIdent, usage, ident($hasDefaultValue), field.defaultValue))) # Register methods diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 90c40e5..317abc8 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -168,18 +168,22 @@ macro baseNativeType(T: typedesc): cstring = rStr.strVal = baseT result = newNimNode(nnkCallStrLit).add(ident("cstring"), rStr) -macro isReference(T: typedesc): bool = - var isRef = false - var t = getType(T) +proc inherits(t: NimNode, parent: string): bool {.compileTime.} = + var curT = t while true: - let typeName = ($t[1][1]).split(':')[0] - if typeName == "Reference": - isRef = true - break + let typeName = ($curT[1][1]).split(':')[0] + if typeName == parent: + return true if typeName == "NimGodotObject": break - t = getType(t[1][1]) - result = if isRef: ident("true") + curT = getType(curT[1][1]) + +macro isReference(T: typedesc): bool = + result = if inherits(getType(T), "Reference"): ident("true") + else: ident("false") + +macro isResource(T: typedesc): bool = + result = if inherits(getType(T), "Resource"): ident("true") else: ident("false") template registerClass*(T: typedesc; godotClassName: cstring, @@ -298,7 +302,7 @@ proc newRStrLit(s: string): NimNode {.compileTime.} = static: import strutils -macro toGodotName(T: typedesc): cstring = +macro toGodotName(T: typedesc): string = var godotName: string if T is GodotString or T is string: godotName = "String" @@ -314,14 +318,17 @@ macro toGodotName(T: typedesc): cstring = else: nameStr + result = newLit(godotName) + +macro asCString(s: static[string]): cstring = result = newNimNode(nnkCallStrLit).add( - ident("cstring"), newRStrLit(godotName)) + ident("cstring"), newRStrLit(s)) proc getSingleton*[T: NimGodotObject](): T = ## Returns singleton of type ``T``. Normally, this should not be used, ## because `godotapigen `_ wraps singleton methods so that ## singleton objects don't have to be provided as parameters. - const godotName = toGodotName(T) + const godotName = asCString(toGodotName(T)) let singleton = getGodotSingleton(godotName) if singleton.isNil: printError("Tried to get non-existing singleton of type " & $godotName) @@ -366,7 +373,7 @@ proc newOwnObj[T: NimGodotObject](name: cstring): T = proc gdnew*[T: NimGodotObject](): T = ## Instantiates new object of type ``T``. - const godotName = toGodotName(T) + const godotName = asCString(toGodotName(T)) const objInfo = classRegistryStatic[godotName] result = when objInfo.isNative: asNimGodotObject[T](getClassConstructor(godotName)()) @@ -432,7 +439,8 @@ proc godotObject*(nimObj: NimGodotObject): ptr GodotObject {.inline.} = proc godotTypeInfo*(T: typedesc[NimGodotObject]): GodotTypeInfo {.inline.} = GodotTypeInfo( variantType: VariantType.Object, - hint: GodotPropertyHint.None, + hint: when isResource(T): GodotPropertyHint.ResourceType + else: GodotPropertyHint.None, hintStr: toGodotName(T) ) From 4b6c76e776fc468ad2ff3e62009b7a1568979f1d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 8 Aug 2017 19:13:51 +0700 Subject: [PATCH 058/160] Dont add base pragma for PhysicsBody methods --- godot/godotapigen.nim | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 510251d..624b123 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -603,7 +603,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], pragma.add(ident("gcsafe")) pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"), newIntLit(0))) - if isVirtual and isBase: + if isVirtual and isBase and typ.name != "PhysicsBody": + # Nim doesn't like `base` on PhysicsBody methods - wtf pragma.add(ident("base")) procDecl.sons[4] = pragma tree.add(procDecl) From a7d9aaef95d615eafb2275d1399e44628d7d5c29 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 8 Aug 2017 21:58:03 +0700 Subject: [PATCH 059/160] Fix initTransform --- godot/core/transforms.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index 6505948..f0a73d0 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -10,7 +10,7 @@ type origin*: Vector3 proc initTransform*(): Transform {.inline.} = - discard + result.basis = initBasis() proc initTransform*(xAxis, yAxis, zAxis, origin: Vector3): Transform {.inline.} = From fcc10071fb89e7363c937aff0256f86dde1f598e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 8 Aug 2017 21:58:17 +0700 Subject: [PATCH 060/160] Fix toVariant for nil values --- godot/core/variants.nim | 9 ++++++--- godot/nim/godotnim.nim | 21 ++++++++++++++++++--- 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/godot/core/variants.nim b/godot/core/variants.nim index 1f0d752..fb046f2 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -71,9 +71,12 @@ proc newVariant*(r: cdouble): Variant {.inline.} = proc newVariant*(s: string): Variant {.inline.} = new(result, variantFinalizer) - var godotStr = s.toGodotString() - initGodotVariant(result.godotVariant, godotStr) - godotStr.deinit() + if s.isNil: + initGodotVariant(result.godotVariant) + else: + var godotStr = s.toGodotString() + initGodotVariant(result.godotVariant, godotStr) + godotStr.deinit() import basis, nodepaths import planes, quats, rect2, rect3, rids diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 317abc8..dac8c95 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -445,7 +445,10 @@ proc godotTypeInfo*(T: typedesc[NimGodotObject]): GodotTypeInfo {.inline.} = ) proc toVariant*(self: NimGodotObject): Variant {.inline.} = - newVariant(self.godotObject) + if self.isNil: + newVariant() + else: + newVariant(self.godotObject) proc fromVariant*[T: NimGodotObject](self: var T, val: Variant): ConversionResult = @@ -460,7 +463,10 @@ proc fromVariant*[T: NimGodotObject](self: var T, result = ConversionResult.TypeError proc toVariant*(self: Variant): Variant {.inline.} = - self + if self.isNil: + newVariant() + else: + self proc fromVariant*(self: var Variant, val: Variant): ConversionResult {.inline.} = @@ -531,7 +537,13 @@ proc godotTypeInfo*(T: typedesc[range]): VariantType {.inline.} = ) proc toVariant*[T: SomeGodotOrNum](val: T): Variant {.inline.} = - newVariant(val) + when val is ref: + if val.isNil: + newVariant() + else: + newVariant(val) + else: + newVariant(val) proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( self: var T, val: Variant): ConversionResult = @@ -717,6 +729,9 @@ proc godotTypeInfo*(T: typedesc[Table|TableRef]): GodotTypeInfo {.inline.} = result.variantType = VariantType.Dictionary proc toVariant*[T: Table or TableRef](t: T): Variant = + when t is ref: + if t.isNil: + return newVariant() var dict = newDictionary() mixin toVariant for k, v in t.pairs(): From 34753b7a27e604a94a29b6f552f6c55fcacfaa05 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 9 Aug 2017 16:34:28 +0700 Subject: [PATCH 061/160] Fix string returns in godotapigen --- godot/godotapigen.nim | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 624b123..9c7ea84 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -93,7 +93,7 @@ proc newCommand(left, right: PNode): PNode = result.add(left) result.add(right) -proc newInfix(left, op, right: PNode): PNode = +proc infix(left, op, right: PNode): PNode = result = newNode(nkInfix) result.add(op) result.add(left) @@ -104,6 +104,11 @@ proc postfix(left: PNode, op: string): PNode = result.add(ident(op)) result.add(left) +proc prefix(op: string, right: PNode): PNode = + result = newNode(nkPrefix) + result.add(ident(op)) + result.add(right) + proc newBracketExpr(first, bracket: PNode): PNode = newNode(nkBracketExpr).addChain(first, bracket) @@ -387,10 +392,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], else: args.len - 1 if not varargsName.isNil: argLenNode = newCall("cint", - newInfix(newIntLit(staticArgsLen), - ident("+"), - newDotExpr(ident(varargsName), ident("len")))) - argsAlloc.add(newCall("godotAlloc", newCall("cint", newInfix( + infix(newIntLit(staticArgsLen), + ident("+"), + newDotExpr(ident(varargsName), ident("len")))) + argsAlloc.add(newCall("godotAlloc", newCall("cint", infix( newCall("sizeof", ident("Variant")), ident("*"), newNode(nkPar).addChain(argLenNode)))) ) @@ -410,7 +415,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if arg.isVarargs: argName = newNode(nkBracketExpr).addChain( ident(varargsName), - newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) + infix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx) let isStandardType = arg.typ in standardTypes let isWrappedType = arg.typ in wrapperTypes @@ -449,7 +454,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newIntLit(staticArgsLen)))) let argLoop = newNode(nkWhileStmt) argConversions.add(argLoop) - argLoop.add(newInfix(ident("idx"), ident("<"), argLenNode) + argLoop.add(infix(ident("idx"), ident("<"), argLenNode) ) argLoop.add(newNode(nkStmtList).addChain( argAsgn, @@ -541,7 +546,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(freeCall) if not varargsName.isNil: let errCheck = newIfStmt( - newInfix(newDotExpr(ident("callError"), ident("error")), ident("!="), + infix(newDotExpr(ident("callError"), ident("error")), ident("!="), newDotExpr(ident("VariantCallErrorType"), ident("OK"))), newNode(nkRaiseStmt).addChain( newCall("newCallError", ident("callError"))) @@ -553,7 +558,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newCall("fromVariant", ident("result"), newCall("newVariant", retValIdent)))) let convCheck = newIfStmt( - newInfix(ident("convErr"), ident("!="), + infix(ident("convErr"), ident("!="), newDotExpr(ident("ConversionResult"), ident("OK"))), newNode(nkRaiseStmt).addChain( newCall("newConversionError", ident("convErr"))) @@ -561,6 +566,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(convErrDef) body.add(convCheck) if isStringRet: + body.add(newNode(nkAsgn).addChain( + ident("result"), prefix("$", retValIdent))) body.add(newCall("deinit", retValIdent)) elif isConversionRet: body.add(newNode(nkAsgn).addChain( From e8ea5fbe275c4fedf21bfb5282429ef28f86230f Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 9 Aug 2017 17:03:48 +0700 Subject: [PATCH 062/160] Rename noExport -> noGdExport --- godot/nim/godotmacros.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index c96b164..505bd29 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -156,7 +156,7 @@ proc parseMethod(meth: NimNode): MethodDecl = assert(meth.kind in {nnkProcDef, nnkMethodDef}) let isGdExport = removePragma(meth, "gdExport") let isNoGodot = (meth.kind != nnkMethodDef and not isGdExport) or - removePragma(meth, "noExport") + removePragma(meth, "noGdExport") result = MethodDecl( name: $meth[0].basename, args: newSeq[VarDecl](), From 53f0f230da7192e0eab0e82695508b5dc470a8cb Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 9 Aug 2017 17:05:29 +0700 Subject: [PATCH 063/160] Up version to 0.5.0 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index bff8646..438687f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.4.1" +version = "0.5.0" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From d43b10bc768bbea983c521acc1a9eb26b83894c0 Mon Sep 17 00:00:00 2001 From: Konstantin Zaitsev Date: Fri, 11 Aug 2017 12:19:54 +0700 Subject: [PATCH 064/160] Fix nil pointer exception for variant from arrays --- godot/core/variants.nim | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/godot/core/variants.nim b/godot/core/variants.nim index fb046f2..c5e2359 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -150,21 +150,27 @@ proc newVariant*(pba: PoolByteArray): Variant {.inline.} = initGodotVariant(result.godotVariant, pba.godotPoolByteArray[]) proc newVariant*(pia: PoolIntArray): Variant {.inline.} = + new(result, variantFinalizer) initGodotVariant(result.godotVariant, pia.godotPoolIntArray[]) proc newVariant*(pra: PoolRealArray): Variant {.inline.} = + new(result, variantFinalizer) initGodotVariant(result.godotVariant, pra.godotPoolRealArray[]) proc newVariant*(psa: PoolStringArray): Variant {.inline.} = + new(result, variantFinalizer) initGodotVariant(result.godotVariant, psa.godotPoolStringArray[]) proc newVariant*(pv2a: PoolVector2Array): Variant {.inline.} = + new(result, variantFinalizer) initGodotVariant(result.godotVariant, pv2a.godotPoolVector2Array[]) proc newVariant*(pv3a: PoolVector3Array): Variant {.inline.} = + new(result, variantFinalizer) initGodotVariant(result.godotVariant, pv3a.godotPoolVector3Array[]) proc newVariant*(pca: PoolColorArray): Variant {.inline.} = + new(result, variantFinalizer) initGodotVariant(result.godotVariant, pca.godotPoolColorArray[]) proc asBool*(self: Variant): bool {.inline.} = From 72e6e774a7ea28fa0a279e669d71a87e7e064819 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 11 Aug 2017 12:30:12 +0700 Subject: [PATCH 065/160] Remove debug code from gdobj --- godot/nim/godotmacros.nim | 2 -- 1 file changed, 2 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 505bd29..238a799 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -654,7 +654,5 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = ## that you can find in `Godot API `_. let typeDef = parseType(definition, callsite()) result = genType(typeDef) - if typeDef.name == "MyObj": - echo repr result {.push warning[Deprecated]: on.} From 6da07cada0f85615e6daf6d1b3873099f64ebac1 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 11 Aug 2017 12:32:58 +0700 Subject: [PATCH 066/160] Up version to 0.5.1 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 438687f..54f6aad 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.0" +version = "0.5.1" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From c5f6d47f3e07e236543ae70f99a2f0f6b75f949c Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 14 Aug 2017 20:21:47 +0700 Subject: [PATCH 067/160] Mark emitSignal as discardable --- godot.nimble | 2 +- godot/godotapigen.nim | 146 ++++++++++++++++++++++++------------------ 2 files changed, 86 insertions(+), 62 deletions(-) diff --git a/godot.nimble b/godot.nimble index 54f6aad..5fdb57c 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.1" +version = "0.5.2" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 9c7ea84..ac50246 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -255,7 +255,17 @@ proc makeConstSection(constObj: JsonNode): PNode = def.add(valNode) result.add(def) -type MethodArg = tuple[name, typ: string, defaultVal: JsonNode, isVarargs: bool] +type + MethodArg = tuple[name, typ: string, defaultVal: JsonNode, isVarargs: bool] + MethodInfo = ref object + name: PNode + godotName: string + typ: GodotType + args: seq[MethodArg] + returnType: string + isVirtual: bool + isBase: bool + isDiscardable: bool const standardTypes = toSet( ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", @@ -337,21 +347,22 @@ proc makeDefaultValue(arg: MethodArg): PNode = [$arg.defaultVal, arg.typ]) proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], - name: PNode, godotMethodName: string, - typ: GodotType, args: seq[MethodArg], - returnType: string, isVirtual, - isBase, withImplementation: bool) = + meth: MethodInfo, withImplementation: bool) = var body: PNode if not withImplementation: body = newNode(nkEmpty) - elif godotMethodName == "_init" and typ.godotName == "Object": + elif meth.godotName == "_init" and meth.typ.godotName == "Object": # It's not real (calling it crashes) and will be removed later, # but we use init() convention in Nim, so it needs to work. body = newNode(nkStmtList).addChain( newNode(nkDiscardStmt).addChain(newNode(nkEmpty))) else: + let methGodotName = if meth.godotName.startsWith('_'): + "underscore" & meth.godotName[1..^1] + else: + meth.godotName var methodBindName = toNimStyle( - typ.name & "_" & godotMethodName & "_method_bind") + meth.typ.name & "_" & methGodotName & "_method_bind") if methodBindName[0].isUpperAscii(): methodBindName[0] = methodBindName[0].toLowerAscii() if methodBindName notin methodBindRegistry: @@ -366,8 +377,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], methodBindRegistry.incl(methodBindName) let nilCheck = newNilCheck(ident(methodBindName), - newCall("getMethod", newCStringLit(typ.godotName), - newCStringLit(godotMethodName)) + newCall("getMethod", newCStringLit(meth.typ.godotName), + newCStringLit(meth.godotName)) ) let vars = newNode(nkVarSection) var varargsName: string @@ -375,8 +386,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var staticArgsLen: int var argLenNode = newIntLit(0) let argsName = ident("argsToPassToGodot") - if args.len > 0: - for arg in args: + if meth.args.len > 0: + for arg in meth.args: if arg.isVarargs: varargsName = arg.name isVarargs = true @@ -388,8 +399,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ident("array"), ident("MAX_ARG_COUNT"), if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) else: ident("pointer")))) - staticArgsLen = if varargsName.isNil: args.len - else: args.len - 1 + staticArgsLen = if varargsName.isNil: meth.args.len + else: meth.args.len - 1 if not varargsName.isNil: argLenNode = newCall("cint", infix(newIntLit(staticArgsLen), @@ -410,7 +421,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], vars.add(newIdentDefs(argsName, newNode(nkEmpty), argsAlloc)) let argConversions = newNode(nkStmtList) - for idx, arg in args: + for idx, arg in meth.args: var argName = ident(arg.name) if arg.isVarargs: argName = newNode(nkBracketExpr).addChain( @@ -429,7 +440,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if not isStandardType and arg.isVarargs: raise newException(ValueError, "Non-standard type $# for varargs params of method $# of type $#" % - [arg.typ, godotMethodName, typ.godotName]) + [arg.typ, meth.godotName, meth.typ.godotName]) if not isStandardType and varargsName.isNil: if arg.typ == "string": argConversions.add(newNode(nkVarSection).addChain( @@ -465,7 +476,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newDotExpr(ident(methodBindName), ident(if isVarargs: "call" else: "ptrCall")), newDotExpr(ident("self"), ident("godotObject")), - if args.len > 0: argsName else: newNode(nkNilLit), + if meth.args.len > 0: argsName else: newNode(nkNilLit), argLenNode, if not isVarargs: ident(retName) else: ident("callError") ) @@ -473,10 +484,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], theCall.sons.delete(3) let freeCall = newCall("godotFree", argsName) body = newNode(nkStmtList) - if typ.isSingleton: - let varName = singletonName(typ.name) + if meth.typ.isSingleton: + let varName = singletonName(meth.typ.name) body.add(newNilCheck(varName, newCall( - newBracketExpr(ident("getSingleton"), ident(typ.name))))) + newBracketExpr(ident("getSingleton"), ident(meth.typ.name))))) body.add(newNode(nkLetSection).addChain(newIdentDefs( ident("self"), newNode(nkEmpty), varName ))) @@ -494,26 +505,26 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var isStringRet: bool var isWrapperRet: bool let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName) - if not returnType.isNil and not isVarargs: + if not meth.returnType.isNil and not isVarargs: var addrToAssign = newCall("addr", retValIdent) - if returnType in smallIntTypes: + if meth.returnType in smallIntTypes: isConversionRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("int64"), ))) - elif returnType in float32Types: + elif meth.returnType in float32Types: isConversionRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("float64"), ))) - elif returnType in wrapperTypes: + elif meth.returnType in wrapperTypes: isWrapperRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, ident("Godot" & returnType), + retValIdent, ident("Godot" & meth.returnType), ))) - elif returnType in standardTypes: + elif meth.returnType in standardTypes: addrToAssign = newCall("addr", ident("result")) - elif returnType == "string": + elif meth.returnType == "string": isStringRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("GodotString"), @@ -528,7 +539,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if not isVarargs: body.add(theCall) else: - if not returnType.isNil: + if not meth.returnType.isNil: isVariantRet = true let callStmt = newNode(nkLetSection).addChain( newIdentDefs( @@ -538,11 +549,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(callStmt) if varargsName.isNil: - for idx, arg in args: + for idx, arg in meth.args: if arg.typ == "string": body.add(newCall("deinit", ident("argToPassToGodot" & $idx))) - if args.len > 0 and not varargsName.isNil: + if meth.args.len > 0 and not varargsName.isNil: body.add(freeCall) if not varargsName.isNil: let errCheck = newIfStmt( @@ -572,11 +583,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], elif isConversionRet: body.add(newNode(nkAsgn).addChain( ident("result"), - newCall(returnType, retValIdent))) + newCall(meth.returnType, retValIdent))) elif isWrapperRet: body.add(newNode(nkAsgn).addChain( ident("result"), - newCall("new" & returnType, retValIdent))) + newCall("new" & meth.returnType, retValIdent))) elif isObjRet: body.add(newNode(nkAsgn).addChain(ident("result"), newCall(newBracketExpr(ident("asNimGodotObject"), @@ -585,45 +596,42 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(newNode(nkAsgn).addChain(ident("result"), newCall("$", retValIdent))) - let procType = if isVirtual: nkMethodDef + let procType = if meth.isVirtual: nkMethodDef else: nkProcDef - var params = newSeqOfCap[PNode](args.len + 2) - if not returnType.isNil: - params.add(ident(returnType)) + var params = newSeqOfCap[PNode](meth.args.len + 2) + if not meth.returnType.isNil: + params.add(ident(meth.returnType)) else: params.add(newNode(nkEmpty)) - if not typ.isSingleton: - params.add(newIdentDefs(ident("self"), ident(toNimType(typ.name)))) + if not meth.typ.isSingleton: + params.add(newIdentDefs(ident("self"), ident(toNimType(meth.typ.name)))) - for arg in args: + for arg in meth.args: if arg.isVarargs: params.add(newIdentDefs(ident(arg.name), newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) else: let defaultValue = arg.makeDefaultValue() params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue)) - let procDecl = newProc(if not withImplementation: postfix(name, "*") - else: name, + let procDecl = newProc(if not withImplementation: postfix(meth.name, "*") + else: meth.name, params, body, procType) if not withImplementation: let pragma = newNode(nkPragma) pragma.add(ident("gcsafe")) pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"), newIntLit(0))) - if isVirtual and isBase and typ.name != "PhysicsBody": + if meth.isVirtual and meth.isBase and meth.typ.name != "PhysicsBody": # Nim doesn't like `base` on PhysicsBody methods - wtf pragma.add(ident("base")) + if meth.isDiscardable and not meth.returnType.isNil: + pragma.add(ident("discardable")) procDecl.sons[4] = pragma tree.add(procDecl) proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string], - name: PNode, godotMethodName: string, - typ: GodotType, args: seq[MethodArg], - returnType: string, - isVirtual, isBase, withImplementation: bool) = - doGenerateMethod( - tree, methodBindRegistry, name, godotMethodName, typ, - args, returnType, isVirtual, isBase, withImplementation) + meth: MethodInfo, withImplementation: bool) = + doGenerateMethod(tree, methodBindRegistry, meth, withImplementation) proc makeProperty(types: Table[string, GodotType], tree: PNode, methodBindRegistry: var HashSet[string], @@ -634,14 +642,21 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode, let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) let nimType = toNimType(types, propertyObj["type"].str) - generateMethod(tree, methodBindRegistry, - getterName, propertyObj["getter"].str, typ, - @[], nimType, isVirtual = false, - isBase = false, withImplementation) - generateMethod(tree, methodBindRegistry, - setterName, propertyObj["setter"].str, typ, - @[("val", nimType, JsonNode(nil), false)], - nil, isVirtual = false, isBase = false, withImplementation) + let getterInfo = MethodInfo( + name: getterName, + typ: typ, + godotName: propertyObj["getter"].str, + args: @[], + returnType: nimType + ) + let setterInfo = MethodInfo( + name: setterName, + typ: typ, + godotName: propertyObj["setter"].str, + args: @[("val", nimType, JsonNode(nil), false)] + ) + generateMethod(tree, methodBindRegistry, getterInfo, withImplementation) + generateMethod(tree, methodBindRegistry, setterInfo, withImplementation) proc makeMethod(types: Table[string, GodotType], tree: PNode, methodBindRegistry: var HashSet[string], @@ -688,11 +703,20 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, if meth["name"].str == '_' & godotName: nimName = nimName & "Impl" - generateMethod(tree, methodBindRegistry, - ident(nimName), methodObj["name"].str, - typ, args, - returnType, methodObj["is_virtual"].bval, isBase, - withImplementation) + const discardableMethods = toSet(["emit_signal"]) + let methodInfo = MethodInfo( + name: ident(nimName), + typ: typ, + godotName: methodObj["name"].str, + args: args, + returnType: returnType, + isVirtual: methodObj["is_virtual"].bval, + isBase: isBase, + isDiscardable: typ.godotName == "Object" and + methodObj["name"].str in discardableMethods + ) + + generateMethod(tree, methodBindRegistry, methodInfo, withImplementation) proc addAttributeToDoc(doc: var string, propName, propValue: string) = if doc.len > 0: From 8d49c0b9108afe1e6d00dd3c31272d96544695e3 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 15 Aug 2017 10:45:57 +0700 Subject: [PATCH 068/160] Register singleton-derived types. Fixes #8 --- godot.nimble | 2 +- godot/godotapigen.nim | 45 +++++++++++++++++++++++++++++++------------ 2 files changed, 34 insertions(+), 13 deletions(-) diff --git a/godot.nimble b/godot.nimble index 5fdb57c..57b2cc0 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.2" +version = "0.5.3" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index ac50246..a77bca9 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -765,14 +765,14 @@ proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool = curTyp = types.getOrDefault(curTyp.baseName) result = curTyp.isNil -proc genTypeFile(types: var Table[string, GodotType], targetDir: string) = - for typ in types.values(): - types.incDerivedCount(typ.baseName) - - var sortedTypes = toSeq(types.values()) - sortedTypes.sort do (x, y: GodotType) -> int: +proc sortByDerivedCount(types: Table[string, GodotType]): seq[GodotType] = + result = toSeq(types.values()) + result.sort do (x, y: GodotType) -> int: cmp(y.derivedCount, x.derivedCount) +proc genTypeFile(types: Table[string, GodotType], targetDir: string) = + let sortedTypes = sortByDerivedCount(types) + let godotApiTypesTree = newNode(nkStmtList) godotApiTypesTree.add(newNode(nkImportStmt).addChain(ident("godot"))) let typeSection = newNode(nkTypeSection) @@ -793,6 +793,28 @@ proc genTypeFile(types: var Table[string, GodotType], targetDir: string) = renderModule(godotApiTypesTree, targetDir / "godottypes.nim") +proc genSingletonWithDerived(tree: PNode, typ: GodotType, + types: Table[string, GodotType]) = + let sortedTypes = sortByDerivedCount(types) + + var parents = initSet[string]() + parents.incl(typ.name) + + let typeDecl = newNode(nkTypeSection) + tree.add(typeDecl) + proc genDecl(typ: GodotType) = + newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc, + isExported = false) + tree.add(newRegisterClassNode(typ)) + + genDecl(typ) + for otherType in sortedTypes: + if otherType.baseName in parents: + parents.incl(otherType.baseName) + genDecl(otherType) + + tree.add(genSingletonDecl(typ.name)) + proc genApi*(targetDir: string, apiJsonFile: string) = ## Generates .nim files in the ``targetDir`` based on the ``apiJsonFile``. ## The JSON file can be generated by executing Godot with @@ -821,6 +843,10 @@ proc genApi*(targetDir: string, apiJsonFile: string) = jsonNode: obj, isSingleton: obj["singleton"].bval ) + + for typ in types.values(): + types.incDerivedCount(typ.baseName) + for typ in types.values(): let moduleName = typeNameToModuleName(typ.name) echo "Generating ", moduleName, ".nim..." @@ -850,12 +876,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) = tree.add(makeConstSection(obj["constants"])) if typ.isSingleton: - let typeDecl = newNode(nkTypeSection) - newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc, - isExported = false) - tree.add(typeDecl) - tree.add(newRegisterClassNode(typ)) - tree.add(genSingletonDecl(typ.name)) + genSingletonWithDerived(tree, typ, types) # first, generate declarations only for ease of # human readability of the file From 3d9839ceedd539ad5fa22aa3253eec56e93881b4 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 16 Aug 2017 18:00:07 +0700 Subject: [PATCH 069/160] Fix genSingletonWithDerived --- godot/godotapigen.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index a77bca9..65de77d 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -810,7 +810,7 @@ proc genSingletonWithDerived(tree: PNode, typ: GodotType, genDecl(typ) for otherType in sortedTypes: if otherType.baseName in parents: - parents.incl(otherType.baseName) + parents.incl(otherType.name) genDecl(otherType) tree.add(genSingletonDecl(typ.name)) From f54de5cd46b96907eb3f8274b263d4ff431d068a Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 17 Aug 2017 16:52:11 +0700 Subject: [PATCH 070/160] Remove wrong assertion (false for references) --- godot/nim/godotnim.nim | 2 -- 1 file changed, 2 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index dac8c95..da3f2c6 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -140,8 +140,6 @@ proc deinit*(obj: NimGodotObject) = assert(not obj.godotObject.isNil) obj.godotObject.deinit() obj.godotObject = nil - # linked object internal pointer should be unset from destructor - assert(obj.linkedObject.isNil or obj.linkedObject.godotObject.isNil) proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) = if obj.godotObject.isNil: return From 7a96e33f7446b726ef1d66d180f9e05efa9449ea Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 17 Aug 2017 17:47:27 +0700 Subject: [PATCH 071/160] Treat process and fixed process as multilevel calls --- godot/nim/godotmacros.nim | 2 ++ 1 file changed, 2 insertions(+) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 238a799..5a9a16c 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -539,6 +539,8 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = GodotVariant {.noconv.} = let self = cast[classNameIdent](userData) const isStaticCall = methodNameLit == cstring"_ready" or + methodNameLit == cstring"_process" or + methodNameLit == cstring"_fixed_process" or methodNameLit == cstring"_enter_tree" or methodNameLit == cstring"_exit_tree" or methodNameLit == cstring"_enter_world" or From 3349fe232175fc4856c89988536bdf7da935be6e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 17 Aug 2017 18:41:24 +0700 Subject: [PATCH 072/160] Up version to v0.5.4 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 57b2cc0..dda8cf9 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.3" +version = "0.5.4" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From fda800fd26b218661ace91801a9ce7bbce8e6afc Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 23 Aug 2017 13:29:32 +0700 Subject: [PATCH 073/160] Avoid using godot_get_stack_bottom It's not reliable on Android. --- godot/godotinternal.nim | 3 --- godot/nim/godotnim.nim | 8 ++++++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index fe253dc..c241d77 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -239,9 +239,6 @@ type ClassConstructor = proc (): ptr GodotObject {.noconv.} proc getClassConstructor*(className: cstring): ClassConstructor {. importc: "godot_get_class_constructor".} -proc godotStackBottom*(): pointer {. - importc: "godot_get_stack_bottom".} - proc deinit*(o: ptr GodotObject) {. importc: "godot_object_destroy".} diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index da3f2c6..bfb59c7 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -780,10 +780,10 @@ proc godot_nativescript_init(handle: pointer) {. cdecl, exportc, dynlib.} = nativeLibHandle = handle - let stackBottom = godotStackBottom() + var stackBottom {.volatile.}: pointer {.emit: """ NimMain(); - setStackBottom(`stackBottom`); + setStackBottom((void*)(&`stackBottom`)); """.} GC_fullCollect() GC_disable() @@ -798,6 +798,10 @@ proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. const nimGcStepLengthUs {.intdefine.} = 2000 proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = + var stackBottom {.volatile.}: pointer + {.emit: """ + setStackBottom((void*)(&`stackBottom`)); + """.} if asyncdispatch.hasPendingOperations(): poll(0) GC_step(nimGcStepLengthUs, true, 0) From 2c226b90e26a4ad87f6035a0e09c4a898826c93d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 23 Aug 2017 13:30:08 +0700 Subject: [PATCH 074/160] Support of enums in API generator --- godot/godotapigen.nim | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 65de77d..f718c60 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -164,13 +164,16 @@ proc incDerivedCount(types: var Table[string, GodotType], types.incDerivedCount(typ.baseName) proc toNimType(godotType: string): string = - case godotType: + result = case godotType: of "float": "float64" of "int": "int64" of "String": "string" of "File": "godottypes.File" else: godotType + if result.startsWith("enum."): + result = if result == "enum.Error": "Error" else: "int64" + proc toNimType(types: Table[string, GodotType], godotType: string): string = let origType = if godotType.contains(','): @@ -878,6 +881,18 @@ proc genApi*(targetDir: string, apiJsonFile: string) = if typ.isSingleton: genSingletonWithDerived(tree, typ, types) + if "enums" in obj: + # Quite often Godot enums are flags that need to be bitwise ORed + # Nim's enums don't serve well for that purpose, so we just generate + # integer constants. The only enum used in API is Error. + for enumDef in obj["enums"]: + let uniqueConstants = newJObject() + for k, v in enumDef["values"]: + if k notin obj["constants"]: + uniqueConstants[k] = v + if uniqueConstants.len > 0: + tree.add(makeConstSection(uniqueConstants)) + # first, generate declarations only for ease of # human readability of the file for property in obj["properties"]: From 7e230480488d066eebf41dc594ca363bb28fcaf1 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 23 Aug 2017 13:30:24 +0700 Subject: [PATCH 075/160] Up version to 0.5.5 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index dda8cf9..0945d17 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.4" +version = "0.5.5" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From 2db2e413a93e2da85509635349ae24962364ef8d Mon Sep 17 00:00:00 2001 From: Konstantin Zaitsev Date: Mon, 4 Sep 2017 12:12:07 +0700 Subject: [PATCH 076/160] Fix transform `xform` methods for rect3 --- godot/core/transforms.nim | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index f0a73d0..7765ab3 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -54,9 +54,9 @@ proc xformVector3*(self: Transform; v: Vector3): Vector3 {. importc: "godot_transform_xform_vector3".} proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {. importc: "godot_transform_xform_inv_vector3".} -proc xformRect3*(self: Transform; v: Vector3): Rect3 {. +proc xformRect3*(self: Transform; v: Rect3): Rect3 {. importc: "godot_transform_xform_rect3".} -proc xformInvRect3*(self: Transform; v: Vector3): Vector3 {. +proc xformInvRect3*(self: Transform; v: Rect3): Rect3 {. importc: "godot_transform_xform_inv_rect3".} proc `==`*(self: Transform; b: Transform): bool {. From e3c014a3596196ba415dbe34443b895ac5f6b36a Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Sep 2017 15:21:25 +0700 Subject: [PATCH 077/160] Up version to 0.5.6 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 0945d17..e3ae641 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.5" +version = "0.5.6" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From b5fd4295e63f35a3e5bc5cd60f22077d890c5a1a Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Sep 2017 19:29:59 +0700 Subject: [PATCH 078/160] Always generate init with super call --- godot.nimble | 2 +- godot/nim/godotmacros.nim | 39 ++++++++++++++++++++------------------- 2 files changed, 21 insertions(+), 20 deletions(-) diff --git a/godot.nimble b/godot.nimble index e3ae641..badccf4 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.6" +version = "0.5.7" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 5a9a16c..0fa2d9f 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -451,25 +451,26 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = else: postfix(decl.name, "*") recList.add(newIdentDefs(name, decl.typ)) - # Add default values to init method - if initBody.len > 0: - var initMethod: NimNode - for meth in obj.methods: - if meth.name == "init" and meth.nimNode[3].len == 1: - initMethod = meth.nimNode - break - if initMethod.isNil: - obj.methods.add(MethodDecl( - name: "init", - args: newSeq[VarDecl](), - returnType: newEmptyNode(), - isVirtual: true, - isNoGodot: false, - nimNode: newProc(ident("init"), body = initBody, - procType = nnkMethodDef) - )) - else: - initMethod.body.insert(0, initBody) + # Add default values and/or super call to init method + initBody.insert(0, newNimNode(nnkCommand).add(ident("procCall"), + newCall("init", newCall(obj.parentName, ident("self"))))) + var initMethod: NimNode + for meth in obj.methods: + if meth.name == "init" and meth.nimNode[3].len == 1: + initMethod = meth.nimNode + break + if initMethod.isNil: + obj.methods.add(MethodDecl( + name: "init", + args: newSeq[VarDecl](), + returnType: newEmptyNode(), + isVirtual: true, + isNoGodot: false, + nimNode: newProc(ident("init"), body = initBody, + procType = nnkMethodDef) + )) + else: + initMethod.body.insert(0, initBody) # {.this: self.} for convenience result.add(newNimNode(nnkPragma).add(newNimNode(nnkExprColonExpr).add( From ee53768c13feed2cdb279f8b518493da7ec7cf67 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Sep 2017 20:28:13 +0700 Subject: [PATCH 079/160] Export generated init --- godot.nimble | 2 +- godot/nim/godotmacros.nim | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index badccf4..fa351a8 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.7" +version = "0.5.8" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 0fa2d9f..9ff9b66 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -466,7 +466,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = returnType: newEmptyNode(), isVirtual: true, isNoGodot: false, - nimNode: newProc(ident("init"), body = initBody, + nimNode: newProc(postfix(ident("init"), "*"), body = initBody, procType = nnkMethodDef) )) else: From 99934854d035d6e0a4f4fd376bcd819a6d1d2acd Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 13 Sep 2017 20:52:08 +0700 Subject: [PATCH 080/160] Fix Reference handling --- godot/nim/godotmacros.nim | 18 ++++++++++++------ godot/nim/godotnim.nim | 33 ++++++++++++++++++++++----------- 2 files changed, 34 insertions(+), 17 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 9ff9b66..53495c6 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -313,23 +313,29 @@ proc refcountIncremented(obj: ptr GodotObject, methodData: pointer, userData: pointer, numArgs: cint, args: var array[MAX_ARG_COUNT, ptr GodotVariant]): GodotVariant {.noconv.} = - GC_ref(cast[NimGodotObject](userData)) + let nimObj = cast[NimGodotObject](userData) + if not nimObj.isFinalized: + GC_ref(nimObj) proc refcountDecremented(obj: ptr GodotObject, methodData: pointer, userData: pointer, numArgs: cint, args: var array[MAX_ARG_COUNT, ptr GodotVariant]): GodotVariant {.noconv.} = - GC_unref(cast[NimGodotObject](userData)) - initGodotVariant(result, false) # destroy when Nim decides + let nimObj = cast[NimGodotObject](userData) + if not nimObj.isFinalized: + GC_unref(nimObj) + initGodotVariant(result, nimObj.isFinalized) -template registerGodotClass(classNameIdent, classNameLit, isRef, +template registerGodotClass(classNameIdent, classNameLit; isRefClass: bool; baseNameLit, createFuncIdent; isTool: bool) = proc createFuncIdent(obj: ptr GodotObject, methData: pointer): pointer {.noconv.} = var nimObj: classNameIdent new(nimObj, nimGodotObjectFinalizer[classNameIdent]) nimObj.setGodotObject(obj) - nimObj.setNativeObject(asNimGodotObject[NimGodotObject](obj, noRef = true)) + nimObj.isRef = when isRefClass: true else: false + nimObj.setNativeObject(asNimGodotObject[NimGodotObject]( + obj, forceNativeObject = true)) GC_ref(nimObj) result = cast[pointer](nimObj) when compiles(nimObj.init()): @@ -339,7 +345,7 @@ template registerGodotClass(classNameIdent, classNameLit, isRef, createFunc: createFuncIdent ) let destroyFuncObj = GodotInstanceDestroyFunc( - destroyFunc: when isRef: nimDestroyRefFunc else: nimDestroyFunc + destroyFunc: when isRefClass: nimDestroyRefFunc else: nimDestroyFunc ) registerClass(classNameIdent, classNameLit, false) when isTool: diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index bfb59c7..b4420c0 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -38,7 +38,9 @@ type ## ``Particles`` is valid, but Nim type system is not aware of that. ## This works in both directions - for linked native object this ## reference points to Nim object. - isExternalRef: bool + isRef*: bool + isFinalized: bool + isNative: bool ConversionResult* {.pure.} = enum ## Conversion result to return from ``fromVariant`` procedure. @@ -86,6 +88,9 @@ type ## values. ## See documentation of ``GodotPropertyHint`` for description of formats. +proc isFinalized*(obj: NimGodotObject): bool {.inline.} = + obj.isFinalized + template printWarning*(warning: typed) = ## Prints ``warning`` to Godot log, adding filename and line information. let (filename, line) = instantiationInfo() @@ -128,11 +133,11 @@ proc unreference(o: ptr GodotObject): bool = unreferenceMethodBind.ptrCall(o, nil, addr(result)) var referenceMethodBind {.threadvar.}: ptr GodotMethodBind -proc reference(o: ptr GodotObject) = +proc reference(o: ptr GodotObject): bool {.discardable.} = if isNil(referenceMethodBind): referenceMethodBind = getMethod(cstring"Reference", cstring"reference") - referenceMethodBind.ptrCall(o, nil, nil) + referenceMethodBind.ptrCall(o, nil, addr result) proc deinit*(obj: NimGodotObject) = ## Destroy the object. You only need to call this for objects not inherited @@ -142,10 +147,11 @@ proc deinit*(obj: NimGodotObject) = obj.godotObject = nil proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) = - if obj.godotObject.isNil: return - if obj.isExternalRef and obj.godotObject.unreference(): - obj.deinit() - elif not obj.linkedObject.isNil: + if obj.godotObject.isNil or obj.isNative: return + # important to set it before so that ``unreference`` is aware + obj.isFinalized = true + if obj.isRef and obj.godotObject.unreference() or + not obj.linkedObject.isNil: obj.deinit() macro baseNativeType(T: typedesc): cstring = @@ -228,25 +234,25 @@ proc newNimGodotObject[T: NimGodotObject]( else: result = T(objInfo.constructor()) result.godotObject = godotObject + result.isRef = objInfo.isRef if not noRef and objInfo.isRef: - result.isExternalRef = true result.godotObject.reference() proc asNimGodotObject*[T: NimGodotObject]( - godotObject: ptr GodotObject, noRef: bool = false): T = + godotObject: ptr GodotObject, forceNativeObject: bool = false): T = ## Wraps ``godotObject`` into Nim type ``T``. ## This is used by `godotapigen `_ and should rarely be ## used by anything else. if godotObject.isNil: return nil let userDataPtr = godotObject.getUserData() - if not userDataPtr.isNil: + if not userDataPtr.isNil and not forceNativeObject: result = cast[T](userDataPtr) if result.godotObject != godotObject: # Could be data from other bindings result = nil if result.isNil: result = newNimGodotObject[T]( - godotObject, cstring(godotObject.getClassName()), noRef) + godotObject, cstring(godotObject.getClassName()), forceNativeObject) proc newVariant*(obj: NimGodotObject): Variant {.inline.} = newVariant(obj.godotObject) @@ -367,6 +373,10 @@ proc newOwnObj[T: NimGodotObject](name: cstring): T = "but it returned: " & $ret.getType()) else: result = asNimGodotObject[T](ret.asGodotObject()) + if result.isRef: + result.isFinalized = true + result.godotObject.reference() + result.isFinalized = false ret.deinit() proc gdnew*[T: NimGodotObject](): T = @@ -417,6 +427,7 @@ proc setNativeObject*(nimObj: NimGodotObject, ## Used from Godot constructor produced by ``gdobj`` macro. Do not call. nimObj.linkedObject = nativeObj nativeObj.linkedObject = nimObj + nativeObj.isNative = true proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} = ## Used from Godot destructor produced by ``gdobj`` macro. Do not call. From 77a8cf7815ea39f51a4148ede50ce597ce727178 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 14 Sep 2017 11:04:34 +0700 Subject: [PATCH 081/160] Replace ~ with of --- godot/nim/godotnim.nim | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index b4420c0..26ee4be 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -287,17 +287,12 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = T.name & "\n" & getStackTrace()) result = nil -proc `~`*[T: NimGodotObject](obj: NimGodotObject, - t: typedesc[T]): bool {.inline.} = - ## Godot-specific inheritance check. You must use this over Nim's standard - ## ``of`` operator, because Nim does not know which object your script is - ## attached to in runtime. For example, if you create a - ## ``gdobj Bullet of Spatial`` and the ``Bullet`` is attached to a - ## ``MeshInstance``, ``myBullet of MeshInstance`` will return ``false``, but - ## ``myBullet ~ MeshInstance`` will return ``true``. - ## This is going to be changed to ``of`` in later versions, when Nim starts - ## supporting overloading ``of`` operator. - not obj.isNil and (obj of T or obj.linkedObject of T) +proc `of`*[T: NimGodotObject](obj: NimGodotObject, + t: typedesc[T]): bool {.inline.} = + ## Godot-specific inheritance check. + not obj.isNil and (system.`of`(obj, T) or system.`of`(obj.linkedObject, T)) + +{.deprecated: [`~`: `of`].} proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) From 178192651f08f26610b71caf33d2d674fb4ff67f Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 14 Sep 2017 11:04:52 +0700 Subject: [PATCH 082/160] Update docs regarding Nim version --- docs/index.rst | 11 ++++------- godot.nimble | 2 +- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index 4886466..320e99a 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -52,16 +52,13 @@ about compiling Godot can be found in `Godot documentation `_. -Building Nim +Installing Nim ------------- -The library requires a not yet released Nim version 0.17.1, which you can -build yourself by following instructions in the -`Nim repository `_. Make sure to also run -``./koch tools -d:release`` after the steps described there to build ``nimble`` -(package manager) and ``nimsuggest`` (IDE helper tool, -used by VSCode Nim plugin) +The library requires Nim version 0.17.2 or newer, which you can get here: +https://nim-lang.org/install.html +Make sure you also have ``nimble`` (Nim's package manager) installed. Creating Project ---------------- diff --git a/godot.nimble b/godot.nimble index fa351a8..7425e63 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.8" +version = "0.5.9" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From cf75723fa154c75204807256483ac24833b9fced Mon Sep 17 00:00:00 2001 From: Evgeny Zuev Date: Tue, 19 Sep 2017 17:47:28 +0700 Subject: [PATCH 083/160] Fix crash when passing nil seq to godot Up version to 0.5.10 --- godot.nimble | 2 +- godot/nim/godotnim.nim | 12 ++++++++++-- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/godot.nimble b/godot.nimble index 7425e63..15cf592 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.9" +version = "0.5.10" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 26ee4be..edc6f2e 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -689,12 +689,20 @@ proc godotTypeInfo*(T: typedesc[seq]): GodotTypeInfo = proc godotTypeInfo*(T: typedesc[array]): GodotTypeInfo = arrTypeInfo(T) -proc toVariant*[T](s: openarray[T]): Variant = +template arrayToVariant(s: untyped): Variant = var arr = newArray() mixin toVariant for item in s: arr.add(toVariant(item)) - result = newVariant(arr) + newVariant(arr) + +proc toVariant*[T](s: seq[T]): Variant = + if s.isNil: + return newVariant() + result = arrayToVariant(s) + +proc toVariant*[I, T](s: array[I, T]): Variant = + result = arrayToVariant(s) proc fromVariant*[T](s: var seq[T], val: Variant): ConversionResult = if val.getType() == VariantType.Nil: From b62db02d8f95a4d481999ef6d53a149e4351f329 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 4 Oct 2017 23:41:15 +0700 Subject: [PATCH 084/160] Use GDNative API struct --- godot.nimble | 2 +- godot/core/arrays.nim | 6 +- godot/core/basis.nim | 5 +- godot/core/colors.nim | 45 +- godot/core/dictionaries.nim | 4 +- godot/core/godotbase.nim | 55 - godot/core/godotcoretypes.nim | 102 ++ godot/core/nodepaths.nim | 3 +- godot/core/planes.nim | 105 +- godot/core/poolarrays.nim | 15 +- godot/core/quats.nim | 127 +-- godot/core/rect2.nim | 73 +- godot/core/rect3.nim | 140 ++- godot/core/rids.nim | 32 +- godot/core/transform2d.nim | 117 +-- godot/core/transforms.nim | 93 +- godot/core/variants.nim | 9 +- godot/core/vector2.nim | 188 ++-- godot/core/vector3.nim | 8 +- godot/gdnativeapi.nim | 1378 +++++++++++++++++++++++++ godot/godot.nim | 7 +- godot/godotinternal.nim | 307 ++---- godot/internal/godotarrays.nim | 197 ++-- godot/internal/godotdictionaries.nim | 84 +- godot/internal/godotinternaltypes.nim | 262 +++++ godot/internal/godotnodepaths.nim | 60 +- godot/internal/godotobjects.nim | 4 - godot/internal/godotpoolarrays.nim | 495 +++------ godot/internal/godotstrings.nim | 41 +- godot/internal/godotvariants.nim | 379 +++---- godot/nim/godotmacros.nim | 28 +- godot/nim/godotnim.nim | 10 +- 32 files changed, 2846 insertions(+), 1535 deletions(-) create mode 100644 godot/core/godotcoretypes.nim create mode 100644 godot/gdnativeapi.nim create mode 100644 godot/internal/godotinternaltypes.nim delete mode 100644 godot/internal/godotobjects.nim diff --git a/godot.nimble b/godot.nimble index 15cf592..b81ad0e 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.5.10" +version = "0.6.0" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 5157e50..414ac99 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,7 +1,7 @@ # Copyright 2017 Xored Software, Inc. import hashes -import internal.godotarrays +import internal.godotinternaltypes, internal.godotarrays type Array* = ref object @@ -125,8 +125,8 @@ proc delete*(self: var Array; idx: int) {.inline.} = proc setLen*(self: var Array; size: int) {.inline.} = self.godotArray.setLen(size.cint) -proc rfind*(self: Array; what: Variant; f: int): int {.inline.} = - self.godotArray.rfind(what.godotVariant[], f.cint).int +proc rfind*(self: Array; what: Variant; fromIdx: int): int {.inline.} = + self.godotArray.rfind(what.godotVariant[], fromIdx.cint).int proc len*(self: Array): int {.inline.} = self.godotArray.len.int diff --git a/godot/core/basis.nim b/godot/core/basis.nim index 75b2aab..6f7e9d9 100644 --- a/godot/core/basis.nim +++ b/godot/core/basis.nim @@ -2,10 +2,7 @@ import math import godotbase, vector3, quats - -type - Basis* {.byref.} = object - elements*: array[3, Vector3] +import godotcoretypes proc setCells*(basis: var Basis, xx, xy, xz, yx, yy, yz, zx, zy, zz: float32) = basis.elements[0].x = xx diff --git a/godot/core/colors.nim b/godot/core/colors.nim index 3d4376a..dedb1a2 100644 --- a/godot/core/colors.nim +++ b/godot/core/colors.nim @@ -1,11 +1,6 @@ # Copyright (c) 2017 Xored Software, Inc. -type - Color* {.byref.} = object - r*: float32 - g*: float32 - b*: float32 - a*: float32 +import godotcoretypes, gdnativeapi proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} = Color( @@ -19,12 +14,14 @@ proc initColor*(): Color {.inline.} = ## Initializes black color with 1.0 alpha initColor(0, 0, 0) -proc h*(self: Color): float32 {. - importc: "godot_color_get_h".} -proc s*(self: Color): float32 {. - importc: "godot_color_get_s".} -proc v*(self: Color): float32 {. - importc: "godot_color_get_v".} +proc h*(self: Color): float32 {.inline.} = + getGDNativeAPI().colorGetH(self) + +proc s*(self: Color): float32 {.inline.} = + getGDNativeAPI().colorGetS(self) + +proc v*(self: Color): float32 {.inline.} = + getGDNativeAPI().colorGetV(self) proc `$`*(self: Color): string {.inline.} = result = newStringOfCap(50) @@ -58,16 +55,20 @@ proc toARGB32*(self: Color): uint32 {.inline.} = result = (result shl 8) or uint8(self.g * 255) result = (result shl 8) or uint8(self.b * 255) -proc gray*(self: Color): float32 {. - importc: "godot_color_gray".} -proc inverted*(self: Color): Color {. - importc: "godot_color_inverted".} -proc contrasted*(self: Color): Color {. - importc: "godot_color_contrasted".} -proc lerp*(self: Color; b: Color; t: float32): Color {. - importc: "godot_color_linear_interpolate".} -proc blend*(self: Color; over: Color): Color {. - importc: "godot_color_blend".} +proc gray*(self: Color): float32 {.inline.} = + getGDNativeAPI().colorGray(self) + +proc inverted*(self: Color): Color {.inline.} = + getGDNativeAPI().colorInverted(self) + +proc contrasted*(self: Color): Color {.inline.} = + getGDNativeAPI().colorContrasted(self) + +proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} = + getGDNativeAPI().colorLinearInterpolate(self, b, t) + +proc blend*(self: Color; over: Color): Color {.inline.} = + getGDNativeAPI().colorBlend(self, over) proc `==`*(a, b: Color): bool {.inline.} = a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 1276c89..5445d27 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,8 +1,8 @@ # Copyright 2017 Xored Software, Inc. import hashes -import internal.godotstrings, internal.godotdictionaries, - internal.godotvariants +import internal.godotinternaltypes, internal.godotdictionaries, + internal.godotvariants, internal.godotstrings type Dictionary* = ref object diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index 0fda0cd..0f410b8 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -2,61 +2,6 @@ import math -type - Error* {.size: sizeof(cint), pure.} = enum - OK, - Failed, ## Generic fail error - Unavailable, ## What is requested is unsupported/unavailable - Unconfigured, ## The object being used hasnt been properly set up yet - Unauthorized, ## Missing credentials for requested resource - ParameterRangeError, ## Parameter given out of range (5) - OutOfMemory, ## Out of memory - FileNotFound, - FileBadDrive, - FileBadPath, - FileNoPermission, ## (10) - FileAlreadyInUse, - FileCantOpen, - FileCantWrite, - FileCantRead, - FileUnrecognized, ## (15) - FileCorrupt, - FileMissingDependencies, - FileEOF, - CantOpen, ## Can't open a resource/socket/file - CantCreate, ## (20) - QueryFailed, - AlreadyInUse, - Locked, ## resource is locked - Timeout, - CantConnect, ## (25) - CantResolve, - ConnectionError, - CantAquireResource, - CantFork, - InvalidData, ## Data passed is invalid (30) - InvalidParameter, ## Parameter passed is invalid - AlreadyExists, ## When adding, item already exists - DoesNotExist, ## When retrieving/erasing, it item does not exist - DatabaseCantRead, ## Database is full - DatabaseCantWrite, ## Database is full (35) - CompilationFailed, - MethodNotFound, - LinkFailed, - ScriptFailed, - CyclicLink, ## (40) - InvalidDeclaration, - DuplicateSymbol, - PauseError, - Busy, - Skip, ## (45) - Help, ## user requested help!! - Bug, - ## a bug in the software certainly happened, due to a double - ## check failing or unexpected behavior. - PrinterOnFire, ## the parallel port printer is engulfed in flames - WTF ## shit happens, has never been used, though - # math helpers const EPSILON = 0.00001'f32 diff --git a/godot/core/godotcoretypes.nim b/godot/core/godotcoretypes.nim new file mode 100644 index 0000000..8b92407 --- /dev/null +++ b/godot/core/godotcoretypes.nim @@ -0,0 +1,102 @@ +# Copyright 2017 Xored Software, Inc. + +type + Color* {.byref.} = object + r*: float32 + g*: float32 + b*: float32 + a*: float32 + + Vector3* {.byref.} = object + x*: float32 + y*: float32 + z*: float32 + + Vector2* {.byref.} = object + x*: float32 + y*: float32 + + Plane* {.byref.} = object + normal*: Vector3 + d*: float32 + + Basis* {.byref.} = object + elements*: array[3, Vector3] + + Quat* {.byref.} = object + x*: float32 + y*: float32 + z*: float32 + w*: float32 + + Rect3* {.byref.} = object + position*: Vector3 + size*: Vector3 + + Rect2* {.byref.} = object + position*: Vector2 + size*: Vector2 + + Transform2D* {.byref.} = object + elements*: array[3, Vector2] + + Transform* {.byref.} = object + basis*: Basis + origin*: Vector3 + + RID* {.byref.} = object + data: array[sizeof(int), byte] + + Error* {.size: sizeof(cint), pure.} = enum + OK, + Failed, ## Generic fail error + Unavailable, ## What is requested is unsupported/unavailable + Unconfigured, ## The object being used hasnt been properly set up yet + Unauthorized, ## Missing credentials for requested resource + ParameterRangeError, ## Parameter given out of range (5) + OutOfMemory, ## Out of memory + FileNotFound, + FileBadDrive, + FileBadPath, + FileNoPermission, ## (10) + FileAlreadyInUse, + FileCantOpen, + FileCantWrite, + FileCantRead, + FileUnrecognized, ## (15) + FileCorrupt, + FileMissingDependencies, + FileEOF, + CantOpen, ## Can't open a resource/socket/file + CantCreate, ## (20) + QueryFailed, + AlreadyInUse, + Locked, ## resource is locked + Timeout, + CantConnect, ## (25) + CantResolve, + ConnectionError, + CantAquireResource, + CantFork, + InvalidData, ## Data passed is invalid (30) + InvalidParameter, ## Parameter passed is invalid + AlreadyExists, ## When adding, item already exists + DoesNotExist, ## When retrieving/erasing, it item does not exist + DatabaseCantRead, ## Database is full + DatabaseCantWrite, ## Database is full (35) + CompilationFailed, + MethodNotFound, + LinkFailed, + ScriptFailed, + CyclicLink, ## (40) + InvalidDeclaration, + DuplicateSymbol, + PauseError, + Busy, + Skip, ## (45) + Help, ## user requested help!! + Bug, + ## a bug in the software certainly happened, due to a double + ## check failing or unexpected behavior. + PrinterOnFire, ## the parallel port printer is engulfed in flames + WTF ## shit happens, has never been used, though diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index 3bdd41d..62e30f8 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -1,6 +1,7 @@ # Copyright 2017 Xored Software, Inc. -import internal.godotnodepaths, internal.godotstrings +import internal.godotinternaltypes, internal.godotnodepaths, + internal.godotstrings type NodePath* = ref object diff --git a/godot/core/planes.nim b/godot/core/planes.nim index 4c6ead5..360953f 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -2,72 +2,59 @@ import vector3 -import internal.godotstrings +import internal.godotinternaltypes, godotcoretypes, gdnativeapi -type - Plane* {.byref.} = object - normal*: Vector3 - d*: float32 +proc initPlane*(a, b, c, d: float32): Plane {.inline.} = + getGDNativeAPI().planeNewWithReals(result, a, b, c, d) -proc initPlane(dest: var Plane; a, b, c, d: float32) {. - importc: "godot_plane_new_with_reals".} -proc initPlane(dest: var Plane; v1, v2, v3: Vector3) {. - importc: "godot_plane_new_with_vectors".} -proc initPlane(dest: var Plane; normal: Vector3; d: float32) {. - importc: "godot_plane_new_with_normal".} +proc initPlane*(v1, v2, v3: Vector3): Plane {.inline.} = + getGDNativeAPI().planeNewWithVectors(result, v1, v2, v3) -proc initPlane*(a, b, c, d: float32): Plane = - initPlane(result, a, b, c, d) - -proc initPlane*(v1, v2, v3: Vector3): Plane = - initPlane(result, v1, v2, v3) - -proc initPlane*(normal: Vector3; d: float32): Plane = - initPlane(result, normal, d) - -proc toGodotString(self: Plane): GodotString {. - noSideEffect, - importc: "godot_plane_as_string".} +proc initPlane*(normal: Vector3; d: float32): Plane {.inline.} = + result = Plane( + normal: normal, + d: d + ) proc `$`*(self: Plane): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().planeAsString(self) + +proc normalized*(self: Plane): Plane {.inline.} = + getGDNativeAPI().planeNormalized(self) + +proc center*(self: Plane): Vector3 {.inline.} = + getGDNativeAPI().planeCenter(self) + +proc getAnyPoint*(self: Plane): Vector3 {.inline.} = + getGDNativeAPI().planeGetAnyPoint(self) + +proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} = + getGDNativeAPI().planeIsPointOver(self, point) + +proc distanceTo*(self: Plane; point: Vector3): float32 {.inline.} = + getGDNativeAPI().planeDistanceTo(self, point) -proc normalized*(self: Plane): Plane {. - noSideEffect, - importc: "godot_plane_normalized".} -proc center*(self: Plane): Vector3 {. - noSideEffect, - importc: "godot_plane_center".} -proc getAnyPoint*(self: Plane): Vector3 {. - noSideEffect, - importc: "godot_plane_get_any_point".} -proc isPointOver*(self: Plane; point: Vector3): bool {. - noSideEffect, - importc: "godot_plane_is_point_over".} -proc distanceTo*(self: Plane; point: Vector3): float32 {. - noSideEffect, - importc: "godot_plane_distance_to".} proc contains*(self: Plane; point: Vector3; - epsilon: float32): bool {. - noSideEffect, - importc: "godot_plane_has_point".} -proc project*(self: Plane; point: Vector3): Vector3 {. - noSideEffect, - importc: "godot_plane_project".} + epsilon: float32): bool {.inline.} = + getGDNativeAPI().planeHasPoint(self, point, epsilon) + +proc project*(self: Plane; point: Vector3): Vector3 {.inline.} = + getGDNativeAPI().planeProject(self, point) + proc intersect3*(self: Plane; dest: var Vector3; - b, c: Plane): bool {. - noSideEffect, - importc: "godot_plane_intersect_3".} + b, c: Plane): bool {.inline.} = + getGDNativeAPI().planeIntersect3(self, dest, b, c) + proc intersectsRay*(self: Plane; dest: var Vector3; - v, dir: Vector3): bool {. - noSideEffect, - importc: "godot_plane_intersects_ray".} + v, dir: Vector3): bool {.inline.} = + getGDNativeAPI().planeIntersectsRay(self, dest, v, dir) + proc intersectsSegment*(self: Plane; dest: var Vector3; - segmentBegin, segmentEnd: Vector3): bool {. - noSideEffect, importc: "godot_plane_intersects_segment".} -proc `-`*(self: Plane): Plane {. - noSideEffect, - importc: "godot_plane_operator_neg".} -proc `==`*(a, b: Plane): bool {. - noSideEffect, - importc: "godot_plane_operator_equal".} + segmentBegin, segmentEnd: Vector3): bool {.inline.} = + getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd) + +proc `-`*(self: Plane): Plane {.inline.} = + getGDNativeAPI().planeOperatorNeg(self) + +proc `==`*(a, b: Plane): bool {.inline.} = + getGDNativeAPI().planeOperatorEqual(a, b) diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index bb263d2..dd3f544 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -1,7 +1,8 @@ # Copyright 2017 Xored Software, Inc. -import vector2, vector3, colors -import internal.godotpoolarrays, internal.godotstrings +import godotcoretypes +import internal.godotinternaltypes, internal.godotpoolarrays, + internal.godotstrings template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, initProcName) = @@ -51,9 +52,6 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; proc add*(self: var T; data: DataT) {.inline.} = self.fieldName.add(data) - proc addFirst*(self: var T, data: DataT) {.inline.} = - self.fieldName.addFirst(data) - proc insert*(self: var T; idx: int; data: DataT): Error {.inline.} = self.fieldName.insert(idx.cint, data) @@ -93,7 +91,7 @@ definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string, godotPoolStringArray, newPoolStringArray, initGodotPoolStringArray) -import godotbase, arrays +import arrays definePoolArray(PoolByteArray, GodotPoolByteArray, uint8, godotPoolByteArray, newPoolByteArray, @@ -122,11 +120,6 @@ proc add*(self: var PoolStringArray; data: string) = self.godotPoolStringArray.add(s) s.deinit() -proc addFirst*(self: var PoolStringArray, data: string) = - var s = data.toGodotString() - self.godotPoolStringArray.addFirst(s) - s.deinit() - proc insert*(self: var PoolStringArray; idx: int; data: string): Error = var s = data.toGodotString() result = self.godotPoolStringArray.insert(idx.cint, s) diff --git a/godot/core/quats.nim b/godot/core/quats.nim index 9e12d55..016bbd0 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -1,91 +1,78 @@ # Copyright (c) 2017 Xored Software, Inc. -import vector3 -import internal.godotstrings - -type - Quat* {.byref.} = object - x*: float32 - y*: float32 - z*: float32 - w*: float32 - -proc initQuat(dest: var Quat; x, y, z, w: float32) {. - importc: "godot_quat_new".} -proc initQuat(dest: var Quat; axis: Vector3; angle: float32) {. - importc: "godot_quat_new_with_axis_angle".} +import internal.godotinternaltypes, godotcoretypes, gdnativeapi proc initQuat*(x, y, z, w: float32): Quat {.inline.} = - initQuat(result, x, y, z, w) + result = Quat( + x: x, + y: y, + z: z, + w: w + ) proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} = - initQuat(result, axis, angle) - -proc toGodotString(self: Quat): GodotString {. - noSideEffect, - importc: "godot_quat_as_string".} + getGDNativeAPI().quatNewWithAxisAngle(result, axis, angle) proc `$`*(self: Quat): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().quatAsString(self) + +proc length*(self: Quat): float32 {.inline.} = + getGDNativeAPI().quatLength(self) + +proc lengthSquared*(self: Quat): float32 {.inline.} = + getGDNativeAPI().quatLengthSquared(self) + +proc normalized*(self: Quat): Quat {.inline.} = + getGDNativeAPI().quatNormalized(self) + +proc isNormalized*(self: Quat): bool {.inline.} = + getGDNativeAPI().quatIsNormalized(self) + +proc inverse*(self: Quat): Quat {.inline.} = + getGDNativeAPI().quatInverse(self) + +proc dot*(a, b: Quat): float32 {.inline.} = + getGDNativeAPI().quatDot(a, b) + +proc xform*(self: Quat; v: Vector3): Vector3 {.inline.} = + getGDNativeAPI().quatXform(self, v) + +proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} = + getGDNativeAPI().quatSlerp(self, b, t) + +proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} = + getGDNativeAPI().quatSlerpni(self, b, t) + +proc cubicSlerp*(self, b, preA, postB: Quat; + t: float32): Quat {.inline.} = + getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t) + +proc `*`*(a: Quat, b: float32): Quat {.inline.} = + getGDNativeAPI().quatOperatorMultiply(a, b) -proc length*(self: Quat): float32 {. - noSideEffect, - importc: "godot_quat_length".} -proc lengthSquared*(self: Quat): float32 {. - noSideEffect, - importc: "godot_quat_length_squared".} -proc normalized*(self: Quat): Quat {. - noSideEffect, - importc: "godot_quat_normalized".} -proc isNormalized*(self: Quat): bool {. - noSideEffect, - importc: "godot_quat_is_normalized".} -proc inverse*(self: Quat): Quat {. - noSideEffect, - importc: "godot_quat_inverse".} -proc dot*(a, b: Quat): float32 {. - noSideEffect, - importc: "godot_quat_dot".} -proc xform*(self: Quat; v: Vector3): Vector3 {. - noSideEffect, - importc: "godot_quat_xform".} -proc slerp*(self: Quat; b: Quat; t: float32): Quat {. - noSideEffect, - importc: "godot_quat_slerp".} -proc slerpni*(self: Quat; b: Quat; t: float32): Quat {. - noSideEffect, - importc: "godot_quat_slerpni".} -proc cubicSlerp*(self, b, pre_a, post_b: Quat; - t: float32): Quat {. - noSideEffect, - importc: "godot_quat_cubic_slerp".} -proc `*`*(a: Quat, b: float32): Quat {. - noSideEffect, - importc: "godot_quat_operator_multiply".} proc `*=`*(a: var Quat, b: float32) {.inline.} = a = a * b -proc `+`*(a, b: Quat): Quat {. - noSideEffect, - importc: "godot_quat_operator_add".} +proc `+`*(a, b: Quat): Quat {.inline.} = + getGDNativeAPI().quatOperatorAdd(a, b) + proc `+=`*(a: var Quat, b: Quat) {.inline.} = a = a + b -proc `-`*(a, b: Quat): Quat {. - noSideEffect, - importc: "godot_quat_operator_substract".} +proc `-`*(a, b: Quat): Quat {.inline.} = + getGDNativeAPI().quatOperatorSubtract(a, b) + proc `-=`* (a: var Quat, b: Quat) {.inline.} = a = a - b -proc `/`*(self: Quat; b: float32): Quat {. - noSideEffect, - importc: "godot_quat_operator_divide".} +proc `/`*(self: Quat; b: float32): Quat {.inline.} = + getGDNativeAPI().quatOperatorDivide(self, b) + proc `/=`*(self: var Quat, b: float32) {.inline.} = self = self / b -proc `==`*(a, b: Quat): bool {. - noSideEffect, - importc: "godot_quat_operator_equal".} -proc `-`*(self: Quat): Quat {. - noSideEffect, - importc: "godot_quat_operator_neg".} +proc `==`*(a, b: Quat): bool {.inline.} = + getGDNativeAPI().quatOperatorEqual(a, b) + +proc `-`*(self: Quat): Quat {.inline.} = + getGDNativeAPI().quatOperatorNeg(self) diff --git a/godot/core/rect2.nim b/godot/core/rect2.nim index d2192b1..628e203 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -1,13 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. import vector2 - -import internal.godotstrings - -type - Rect2* {.byref.} = object - position*: Vector2 - size*: Vector2 +import godotcoretypes, internal.godotinternaltypes, gdnativeapi proc initRect2*(pos, size: Vector2): Rect2 {.inline.} = Rect2(position: pos, size: size) @@ -15,40 +9,35 @@ proc initRect2*(pos, size: Vector2): Rect2 {.inline.} = proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline.} = Rect2(position: vec2(x, y), size: vec2(sizeX, sizeY)) -proc toGodotString(self: Rect2): GodotString {. - noSideEffect, - importc: "godot_rect2_as_string".} - proc `$`*(self: Rect2): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().rect2AsString(self) -proc area*(self: Rect2): float32 {. - noSideEffect, - importc: "godot_rect2_get_area".} -proc intersects*(a, b: Rect2): bool {. - noSideEffect, - importc: "godot_rect2_intersects".} -proc encloses*(a, b: Rect2): bool {. - noSideEffect, - importc: "godot_rect2_encloses".} -proc hasNoArea*(self: Rect2): bool {. - noSideEffect, - importc: "godot_rect2_has_no_area".} -proc clip*(a, b: Rect2): Rect2 {. - noSideEffect, - importc: "godot_rect2_clip".} -proc merge*(a, b: Rect2): Rect2 {. - noSideEffect, - importc: "godot_rect2_merge".} -proc contains*(self: Rect2; point: Vector2): bool {. - noSideEffect, - importc: "godot_rect2_has_point".} -proc grow*(self: Rect2; by: float32): Rect2 {. - noSideEffect, - importc: "godot_rect2_grow".} -proc expand*(self: Rect2; to: Vector2): Rect2 {. - noSideEffect, - importc: "godot_rect2_expand".} -proc `==`*(a, b: Rect2): bool {. - noSideEffect, - importc: "godot_rect2_operator_equal".} +proc area*(self: Rect2): float32 {.inline.} = + getGDNativeAPI().rect2GetArea(self) + +proc intersects*(a, b: Rect2): bool {.inline.} = + getGDNativeAPI().rect2Intersects(a, b) + +proc encloses*(a, b: Rect2): bool {.inline.} = + getGDNativeAPI().rect2Encloses(a, b) + +proc hasNoArea*(self: Rect2): bool {.inline.} = + getGDNativeAPI().rect2HasNoArea(self) + +proc clip*(self, b: Rect2): Rect2 {.inline.} = + getGDNativeAPI().rect2Clip(self, b) + +proc merge*(self, b: Rect2): Rect2 {.inline.} = + getGDNativeAPI().rect2Merge(self, b) + +proc contains*(self: Rect2; point: Vector2): bool {.inline.} = + getGDNativeAPI().rect2HasPoint(self, point) + +proc grow*(self: Rect2; by: float32): Rect2 {.inline.} = + getGDNativeAPI().rect2Grow(self, by) + +proc expand*(self: Rect2; to: Vector2): Rect2 {.inline.} = + getGDNativeAPI().rect2Expand(self, to) + +proc `==`*(a, b: Rect2): bool {.inline.} = + getGDNativeAPI().rect2OperatorEqual(a, b) diff --git a/godot/core/rect3.nim b/godot/core/rect3.nim index c695ce9..7a2ef72 100644 --- a/godot/core/rect3.nim +++ b/godot/core/rect3.nim @@ -1,84 +1,72 @@ # Copyright (c) 2017 Xored Software, Inc. -import planes, vector3 - -import internal.godotstrings - -type - Rect3* {.byref.} = object - position*: Vector3 - size*: Vector3 +import godotcoretypes, internal.godotinternaltypes, gdnativeapi proc initRect3*(pos, size: Vector3): Rect3 {.inline.} = Rect3(position: pos, size: size) -proc toGodotString(self: Rect3): GodotString {. - noSideEffect, - importc: "godot_rect3_as_string".} - proc `$`*(self: Rect3): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().rect3AsString(self) -proc area*(self: Rect3): float32 {. - noSideEffect, - importc: "godot_rect3_get_area".} -proc hasNoArea*(self: Rect3): bool {. - noSideEffect, - importc: "godot_rect3_has_no_area".} -proc hasNoSurface*(self: Rect3): bool {. - noSideEffect, - importc: "godot_rect3_has_no_surface".} -proc intersects*(a, b: Rect3): bool {. - noSideEffect, - importc: "godot_rect3_intersects".} -proc encloses*(self, other: Rect3): bool {. - noSideEffect, - importc: "godot_rect3_encloses".} -proc merge*(self, other: Rect3): Rect3 {. - noSideEffect, - importc: "godot_rect3_merge".} -proc intersection*(self, other: Rect3): Rect3 {. - noSideEffect, - importc: "godot_rect3_intersection".} -proc intersectsPlane*(self: Rect3; plane: Plane): bool {. - noSideEffect, - importc: "godot_rect3_intersects_plane".} -proc intersectsSegment*(self: Rect3; start, to: Vector3): bool {. - noSideEffect, - importc: "godot_rect3_intersects_segment".} -proc contains*(self: Rect3; point: Vector3): bool {. - noSideEffect, - importc: "godot_rect3_has_point".} -proc getSupport*(self: Rect3; dir: Vector3): Vector3 {. - noSideEffect, - importc: "godot_rect3_get_support".} -proc getLongestAxis*(self: Rect3): Vector3 {. - noSideEffect, - importc: "godot_rect3_get_longest_axis".} -proc getLongestAxisIndex*(self: Rect3): cint {. - noSideEffect, - importc: "godot_rect3_get_longest_axis_index".} -proc getLongestAxisSize*(self: Rect3): float32 {. - noSideEffect, - importc: "godot_rect3_get_longest_axis_size".} -proc getShortestAxis*(self: Rect3): Vector3 {. - noSideEffect, - importc: "godot_rect3_get_shortest_axis".} -proc getShortestAxisIndex*(self: Rect3): cint {. - noSideEffect, - importc: "godot_rect3_get_shortest_axis_index".} -proc getShortestAxisSize*(self: Rect3): float32 {. - noSideEffect, - importc: "godot_rect3_get_shortest_axis_size".} -proc expand*(self: Rect3; toPoint: Vector3): Rect3 {. - noSideEffect, - importc: "godot_rect3_expand".} -proc grow*(self: Rect3; by: float32): Rect3 {. - noSideEffect, - importc: "godot_rect3_grow".} -proc getEndpoint*(self: Rect3; idx: cint): Vector3 {. - noSideEffect, - importc: "godot_rect3_get_endpoint".} -proc `==`*(a, b: Rect3): bool {. - noSideEffect, - importc: "godot_rect3_operator_equal".} +proc area*(self: Rect3): float32 {.inline.} = + getGDNativeAPI().rect3GetArea(self) + +proc hasNoArea*(self: Rect3): bool {.inline.} = + getGDNativeAPI().rect3HasNoArea(self) + +proc hasNoSurface*(self: Rect3): bool {.inline.} = + getGDNativeAPI().rect3HasNoSurface(self) + +proc intersects*(self, other: Rect3): bool {.inline.} = + getGDNativeAPI().rect3Intersects(self, other) + +proc encloses*(self, other: Rect3): bool {.inline.} = + getGDNativeAPI().rect3Encloses(self, other) + +proc merge*(self, other: Rect3): Rect3 {.inline.} = + getGDNativeAPI().rect3Merge(self, other) + +proc intersection*(self, other: Rect3): Rect3 {.inline.} = + getGDNativeAPI().rect3Intersection(self, other) + +proc intersectsPlane*(self: Rect3; plane: Plane): bool {.inline.} = + getGDNativeAPI().rect3IntersectsPlane(self, plane) + +proc intersectsSegment*(self: Rect3; start, to: Vector3): bool {.inline.} = + getGDNativeAPI().rect3IntersectsSegment(self, start, to) + +proc contains*(self: Rect3; point: Vector3): bool {.inline.} = + getGDNativeAPI().rect3HasPoint(self, point) + +proc getSupport*(self: Rect3; dir: Vector3): Vector3 {.inline.} = + getGDNativeAPI().rect3GetSupport(self, dir) + +proc getLongestAxis*(self: Rect3): Vector3 {.inline.} = + getGDNativeAPI().rect3GetLongestAxis(self) + +proc getLongestAxisIndex*(self: Rect3): cint {.inline.} = + getGDNativeAPI().rect3GetLongestAxisIndex(self) + +proc getLongestAxisSize*(self: Rect3): float32 {.inline.} = + getGDNativeAPI().rect3GetLongestAxisSize(self) + +proc getShortestAxis*(self: Rect3): Vector3 {.inline.} = + getGDNativeAPI().rect3GetShortestAxis(self) + +proc getShortestAxisIndex*(self: Rect3): cint {.inline.} = + getGDNativeAPI().rect3GetShortestAxisIndex(self) + +proc getShortestAxisSize*(self: Rect3): float32 {.inline.} = + getGDNativeAPI().rect3GetShortestAxisSize(self) + +proc expand*(self: Rect3; toPoint: Vector3): Rect3 {.inline.} = + getGDNativeAPI().rect3Expand(self, toPoint) + +proc grow*(self: Rect3; by: float32): Rect3 {.inline.} = + getGDNativeAPI().rect3Grow(self, by) + +proc getEndpoint*(self: Rect3; idx: cint): Vector3 {.inline.} = + getGDNativeAPI().rect3GetEndpoint(self, idx) + +proc `==`*(a, b: Rect3): bool {.inline.} = + getGDNativeAPI().rect3OperatorEqual(a, b) diff --git a/godot/core/rids.nim b/godot/core/rids.nim index 6ec5b86..a113f60 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -1,31 +1,21 @@ -import internal.godotobjects +# Copyright (c) 2017 Xored Software, Inc. -type - RID* {.byref.} = object - data: array[sizeof(int), byte] - -proc initRID(dest: var RID) {. - importc: "godot_rid_new".} -proc initRID(dest: var RID; obj: ptr GodotObject) {. - importc: "godot_rid_new_with_resource".} +import godotcoretypes, internal.godotinternaltypes, gdnativeapi proc initRID*(): RID {.inline.} = - initRID(result) + getGDNativeAPI().ridNew(result) proc initRID*(obj: ptr GodotObject): RID {.inline.} = - initRID(result, obj) - -proc idCInt(self: RID): cint {. - noSideEffect, - importc: "godot_rid_get_id".} + getGDNativeAPI().ridNewWithResource(result, obj) proc id*(self: RID): uint32 {.inline.} = - cast[uint32](self.idCInt()) + cast[uint32](getGDNativeAPI().ridGetId(self)) -proc `$`*(self: RID): string = +proc `$`*(self: RID): string {.inline.} = $self.id -proc `==`*(a, b: RID): bool {. - importc: "godot_rid_operator_equal".} -proc `<`*(a, b: RID): bool {. - importc: "godot_rid_operator_less".} +proc `==`*(a, b: RID): bool {.inline.} = + getGDNativeAPI().ridOperatorEqual(a, b) + +proc `<`*(a, b: RID): bool {.inline.} = + getGDNativeAPI().ridOperatorLess(a, b) diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index fece240..67222c6 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -1,76 +1,73 @@ # Copyright (c) 2017 Xored Software, Inc. -import vector2, rect2 - -import internal.godotstrings - -type - Transform2D* {.byref.} = object - elements*: array[3, Vector2] - -proc initTransform2D(dest: var Transform2D) {. - importc: "godot_transform2d_new_identity".} -proc initTransform2D(dest: var Transform2D; rot: float32; pos: Vector2) {. - importc: "godot_transform2d_new".} -proc initTransform2D(dest: var Transform2D; xAxis, yAxis, origin: Vector2) {. - importc: "godot_transform2d_new_axis_origin".} +import godotcoretypes, internal.godotinternaltypes, gdnativeapi proc initTransform2D*(): Transform2D {.inline.} = - initTransform2D(result) + getGDNativeAPI().transform2DNewIdentity(result) proc initTransform2D*(rot: float32; pos: Vector2): Transform2D {.inline.} = - initTransform2D(result, rot, pos) + getGDNativeAPI().transform2DNew(result, rot, pos) proc initTransform2D*(xAxis, yAxis, origin: Vector2): Transform2D {.inline.} = - initTransform2D(result, xAxis, yAxis, origin) - -proc toGodotString(self: Transform2D): GodotString {. - importc: "godot_transform2d_as_string".} + getGDNativeAPI().transform2DNewAxisOrigin(result, xAxis, yAxis, origin) proc `$`*(self: Transform2D): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().transform2DAsString(self) -proc inverse*(self: Transform2D): Transform2D {. - importc: "godot_transform2d_inverse".} -proc affineInverse*(self: Transform2D): Transform2D {. - importc: "godot_transform2d_affine_inverse".} -proc rotation*(self: Transform2D): float32 {. - importc: "godot_transform2d_get_rotation".} -proc origin*(self: Transform2D): Vector2 {. - importc: "godot_transform2d_get_origin".} -proc scale*(self: Transform2D): Vector2 {. - importc: "godot_transform2d_get_scale".} -proc orthonormalized*(self: Transform2D): Transform2D {. - importc: "godot_transform2d_orthonormalized".} -proc rotated*(self: Transform2D; phi: float32): Transform2D {. - importc: "godot_transform2d_rotated".} -proc scaled*(self: Transform2D; scale: Vector2): Transform2D {. - importc: "godot_transform2d_scaled".} -proc translated*(self: Transform2D; - offset: Vector2): Transform2D {. - importc: "godot_transform2d_translated".} -proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {. - importc: "godot_transform2d_xform_vector2".} -proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {. - importc: "godot_transform2d_xform_inv_vector2".} -proc basisXformVector2*(self: Transform2D; - v: Vector2): Vector2 {. - importc: "godot_transform2d_basis_xform_vector2".} -proc basisXformInvVector2*(self: Transform2D; - v: Vector2): Vector2 {. - importc: "godot_transform2d_basis_xform_inv_vector2".} -proc xformRect2*(self: Transform2D; v: Rect2): Rect2 {. - importc: "godot_transform2d_xform_rect2".} -proc xformInvRect2*(self: Transform2D; v: Rect2): Rect2 {. - importc: "godot_transform2d_xform_inv_rect2".} +proc inverse*(self: Transform2D): Transform2D {.inline.} = + getGDNativeAPI().transform2DInverse(self) + +proc affineInverse*(self: Transform2D): Transform2D {.inline.} = + getGDNativeAPI().transform2DAffineInverse(self) + +proc rotation*(self: Transform2D): float32 {.inline.} = + getGDNativeAPI().transform2DGetRotation(self) + +proc origin*(self: Transform2D): Vector2 {.inline.} = + getGDNativeAPI().transform2DGetOrigin(self) + +proc scale*(self: Transform2D): Vector2 {.inline.} = + getGDNativeAPI().transform2DGetScale(self) + +proc orthonormalized*(self: Transform2D): Transform2D {.inline.} = + getGDNativeAPI().transform2DOrthonormalized(self) + +proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} = + getGDNativeAPI().transform2DRotated(self, phi) + +proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} = + getGDNativeAPI().transform2DScaled(self, scale) + +proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} = + getGDNativeAPI().transform2DTranslated(self, offset) + +proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = + getGDNativeAPI().transform2DXformVector2(self, v) + +proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = + getGDNativeAPI().transform2DXformInvVector2(self, v) + +proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = + getGDNativeAPI().transform2DBasisXformVector2(self, v) + +proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = + getGDNativeAPI().transform2DBasisXformInvVector2(self, v) + +proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} = + getGDNativeAPI().transform2DXformRect2(self, rect) + +proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} = + getGDNativeAPI().transform2DXformInvRect2(self, rect) proc interpolateWith*(self, m: Transform2D; - c: float32): Transform2D {. - importc: "godot_transform2d_interpolate_with".} -proc `==`*(a, b: Transform2D): bool {. - importc: "godot_transform2d_operator_equal".} -proc `*`*(a, b: Transform2D): Transform2D {. - importc: "godot_transform2d_operator_multiply".} + c: float32): Transform2D {.inline.} = + getGDNativeAPI().transform2DInterpolateWith(self, m, c) + +proc `==`*(a, b: Transform2D): bool {.inline.} = + getGDNativeAPI().transform2DOperatorEqual(a, b) + +proc `*`*(a, b: Transform2D): Transform2D {.inline.} = + getGDNativeAPI().transform2DOperatorMultiply(a, b) proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} = a = a * b diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index 7765ab3..550136c 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -1,13 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. -import basis, vector3, planes, rect3 - -import internal.godotstrings - -type - Transform* {.byref.} = object - basis*: Basis - origin*: Vector3 +import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import basis proc initTransform*(): Transform {.inline.} = result.basis = initBasis() @@ -23,45 +17,54 @@ proc initTransform*(xAxis, yAxis, zAxis, proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} = Transform(basis: basis, origin: origin) -proc toGodotString(self: Transform): GodotString {. - importc: "godot_transform_as_string".} - proc `$`*(self: Transform): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().transformAsString(self) + +proc inverse*(self: Transform): Transform {.inline.} = + getGDNativeAPI().transformInverse(self) + +proc affineInverse*(self: Transform): Transform {.inline.} = + getGDNativeAPI().transformAffineInverse(self) + +proc orthonormalized*(self: Transform): Transform {.inline.} = + getGDNativeAPI().transformOrthonormalized(self) -proc inverse*(self: Transform): Transform {. - importc: "godot_transform_inverse".} -proc affineInverse*(self: Transform): Transform {. - importc: "godot_transform_affine_inverse".} -proc orthonormalized*(self: Transform): Transform {. - importc: "godot_transform_orthonormalized".} proc rotated*(self: Transform; axis: Vector3; - phi: float32): Transform {. - importc: "godot_transform_rotated".} -proc scaled*(self: Transform; scale: Vector3): Transform {. - importc: "godot_transform_scaled".} -proc translated*(self: Transform; offset: Vector3): Transform {. - importc: "godot_transform_translated".} -proc lookingAt*(self: Transform; - target, up: Vector3): Transform {. - importc: "godot_transform_looking_at".} + phi: float32): Transform {.inline.} = + getGDNativeAPI().transformRotated(self, axis, phi) -proc xformPlane*(self: Transform; v: Plane): Plane {. - importc: "godot_transform_xform_plane".} -proc xformInvPlane*(self: Transform; v: Plane): Plane {. - importc: "godot_transform_xform_inv_plane".} -proc xformVector3*(self: Transform; v: Vector3): Vector3 {. - importc: "godot_transform_xform_vector3".} -proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {. - importc: "godot_transform_xform_inv_vector3".} -proc xformRect3*(self: Transform; v: Rect3): Rect3 {. - importc: "godot_transform_xform_rect3".} -proc xformInvRect3*(self: Transform; v: Rect3): Rect3 {. - importc: "godot_transform_xform_inv_rect3".} +proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} = + getGDNativeAPI().transformScaled(self, scale) -proc `==`*(self: Transform; b: Transform): bool {. - importc: "godot_transform_operator_equal".} -proc `*`*(a, b: Transform): Transform {. - importc: "godot_transform_operator_multiply".} -proc `*=`*(a: var Transform, b: Transform) {.inline.} = - a = a * b +proc translated*(self: Transform; offset: Vector3): Transform {.inline.} = + getGDNativeAPI().transformTranslated(self, offset) + +proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} = + getGDNativeAPI().transformLookingAt(self, target, up) + +proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} = + getGDNativeAPI().transformXformPlane(self, plane) + +proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} = + getGDNativeAPI().transformXformInvPlane(self, plane) + +proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = + getGDNativeAPI().transformXformVector3(self, v) + +proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = + getGDNativeAPI().transformXformInvVector3(self, v) + +proc xformRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} = + getGDNativeAPI().transformXformRect3(self, rect) + +proc xformInvRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} = + getGDNativeAPI().transformXformInvRect3(self, rect) + +proc `==`*(self: Transform; b: Transform): bool {.inline.} = + getGDNativeAPI().transformOperatorEqual(self, b) + +proc `*`*(self, other: Transform): Transform {.inline.} = + getGDNativeAPI().transformOperatorMultiply(self, other) + +proc `*=`*(self: var Transform, other: Transform) {.inline.} = + self = self * other diff --git a/godot/core/variants.nim b/godot/core/variants.nim index c5e2359..2dcc8d8 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -1,7 +1,8 @@ import tables -import internal.godotobjects, internal.godotvariants, internal.godotpoolarrays, - internal.godotstrings, internal.godotnodepaths +import godotcoretypes +import internal.godotinternaltypes, internal.godotvariants, + internal.godotstrings type Variant* = ref object @@ -267,5 +268,5 @@ proc `<`*(self, other: Variant): bool = proc hashCompare*(self, other: Variant): bool = self.godotVariant.hashCompare(other.godotVariant) -proc booleanize*(self: Variant; isValid: var bool): bool = - self.godotVariant.booleanize(isValid) +proc booleanize*(self: Variant): bool = + self.godotVariant.booleanize() diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 8b9f6da..94b5b40 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -1,109 +1,121 @@ # Copyright (c) 2017 Xored Software, Inc. -import internal.godotstrings - -type - Vector2* {.byref.} = object - x*: float32 - y*: float32 +import internal.godotinternaltypes, godotcoretypes, gdnativeapi proc vec2*(x, y: float32): Vector2 {.inline.} = Vector2(x: x, y: y) -proc toGodotString(self: Vector2): GodotString {. - importc: "godot_vector2_as_string".} - proc `$`*(self: Vector2): string {.inline.} = - $self.toGodotString() + $getGDNativeAPI().vector2AsString(self) -proc normalized*(self: Vector2): Vector2 {. - importc: "godot_vector2_normalized".} -proc length*(self: Vector2): float32 {. - importc: "godot_vector2_length".} -proc angle*(self: Vector2): float32 {. - importc: "godot_vector2_angle".} -proc lengthSquared*(self: Vector2): float32 {. - importc: "godot_vector2_length_squared".} -proc isNormalized*(self: Vector2): bool {. - importc: "godot_vector2_is_normalized".} -proc distanceTo*(self, to: Vector2): float32 {. - importc: "godot_vector2_distance_to".} -proc distanceSquaredTo*(self, to: Vector2): float32 {. - importc: "godot_vector2_distance_squared_to".} -proc angleTo*(self, to: Vector2): float32 {. - importc: "godot_vector2_angle_to".} -proc angleToPoint*(self, to: Vector2): float32 {. - importc: "godot_vector2_angle_to_point".} -proc lerp*(self, b: Vector2; t: float32): Vector2 {. - importc: "godot_vector2_linear_interpolate".} -proc cubicInterpolate*(self, b, pre_a, post_b: Vector2; t: float32): Vector2 {. - importc: "godot_vector2_cubic_interpolate".} -proc rotated*(self: Vector2; phi: float32): Vector2 {. - importc: "godot_vector2_rotated".} -proc tangent*(self: Vector2): Vector2 {. - importc: "godot_vector2_tangent".} -proc floor*(self: Vector2): Vector2 {. - importc: "godot_vector2_floor".} -proc snapped*(self: Vector2; by: Vector2): Vector2 {. - importc: "godot_vector2_snapped".} -proc aspect*(self: Vector2): float32 {. - importc: "godot_vector2_aspect".} -proc dot*(a, b: Vector2): float32 {. - importc: "godot_vector2_dot".} -proc slide*(self, n: Vector2): Vector2 {. - importc: "godot_vector2_slide".} -proc bounce*(self, n: Vector2): Vector2 {. - importc: "godot_vector2_bounce".} -proc reflect*(self, n: Vector2): Vector2 {. - importc: "godot_vector2_reflect".} -proc abs*(self: Vector2): Vector2 {. - importc: "godot_vector2_abs".} -proc clamped*(self: Vector2; length: float32): Vector2 {. - importc: "godot_vector2_clamped".} +proc normalized*(self: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Normalized(self) -proc `+`*(a, b: Vector2): Vector2 {. - importc: "godot_vector2_operator_add".} -proc `+=`*(a: var Vector2, b: Vector2) {.inline.} = - a += b +proc length*(self: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2Length(self) -proc `-`*(a, b: Vector2): Vector2 {. - importc: "godot_vector2_operator_substract".} -proc `-=`*(a: var Vector2, b: Vector2) {.inline.} = - a = a - b +proc angle*(self: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2Angle(self) -proc `*`*(a, b: Vector2): Vector2 {. - importc: "godot_vector2_operator_multiply_vector".} +proc lengthSquared*(self: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2LengthSquared(self) -proc `*=`*(a: var Vector2, b: Vector2) {.inline.} = - a = a * b +proc isNormalized*(self: Vector2): bool {.inline.} = + getGDNativeAPI().vector2IsNormalized(self) + +proc distanceTo*(self, to: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2DistanceTo(self, to) + +proc distanceSquaredTo*(self, to: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2DistanceSquaredTo(self, to) + +proc angleTo*(self, to: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2AngleTo(self, to) + +proc angleToPoint*(self, to: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2AngleToPoint(self, to) + +proc lerp*(self, b: Vector2; t: float32): Vector2 {.inline.} = + getGDNativeAPI().vector2LinearInterpolate(self, b, t) + +proc cubicInterpolate*(self, b, preA, postB: Vector2; + t: float32): Vector2 {.inline.} = + getGDNativeAPI().vector2CubicInterpolate(self, b, preA, postB, t) + +proc rotated*(self: Vector2; phi: float32): Vector2 {.inline.} = + getGDNativeAPI().vector2Rotated(self, phi) + +proc tangent*(self: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Tangent(self) + +proc floor*(self: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Floor(self) + +proc snapped*(self: Vector2; by: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Snapped(self, by) + +proc aspect*(self: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2Aspect(self) + +proc dot*(a, b: Vector2): float32 {.inline.} = + getGDNativeAPI().vector2Dot(a, b) + +proc slide*(self, n: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Slide(self, n) + +proc bounce*(self, n: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Bounce(self, n) + +proc reflect*(self, n: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Reflect(self, n) + +proc abs*(self: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2Abs(self) + +proc clamped*(self: Vector2; length: float32): Vector2 {.inline.} = + getGDNativeAPI().vector2Clamped(self, length) + +proc `+`*(self, other: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2OperatorAdd(self, other) + +proc `+=`*(self: var Vector2, other: Vector2) {.inline.} = + self += other + +proc `-`*(self, other: Vector2): Vector2 = + getGDNativeAPI().vector2OperatorSubtract(self, other) + +proc `-=`*(self: var Vector2, other: Vector2) {.inline.} = + self = self - other + +proc `*`*(self, other: Vector2): Vector2 = + getGDNativeAPI().vector2OperatorMultiplyVector(self, other) + +proc `*=`*(self: var Vector2, other: Vector2) {.inline.} = + self = self * other + +proc `*`*(self: Vector2, scalar: float32): Vector2 = + getGDNativeAPI().vector2OperatorMultiplyScalar(self, scalar) -proc `*`*(self: Vector2, scalar: float32): Vector2 {. - importc: "godot_vector2_operator_multiply_scalar".} proc `*=`*(self: var Vector2, scalar: float32) {.inline.} = self = self * scalar -proc `/`*(a, b: Vector2): Vector2 {. - importc: "godot_vector2_operator_divide_vector".} -proc `/=`*(a: var Vector2, b: Vector2) {.inline.} = - a = a / b +proc `/`*(self, other: Vector2): Vector2 = + getGDNativeAPI().vector2OperatorDivideVector(self, other) + +proc `/=`*(self: var Vector2, other: Vector2) {.inline.} = + self = self / other + +proc `/`*(self: Vector2; scalar: float32): Vector2 = + getGDNativeAPI().vector2OperatorDivideScalar(self, scalar) -proc `/`*(self: Vector2; scalar: float32): Vector2 {. - importc: "godot_vector2_operator_divide_scalar".} proc `/=`*(self: var Vector2; scalar: float32) {.inline.} = self = self / scalar -proc `==`*(a, b: Vector2): bool {. - importc: "godot_vector2_operator_equal".} -proc `<`*(a, b: Vector2): bool {. - importc: "godot_vector2_operator_less".} -proc `-`*(self: Vector2): Vector2 {. - importc: "godot_vector2_operator_neg".} +proc `==`*(self, other: Vector2): bool {.inline.} = + getGDNativeAPI().vector2OperatorEqual(self, other) -proc `x=`*(self: var Vector2; x: float32) {. - importc: "godot_vector2_set_x".} -proc `y=`*(self: var Vector2; y: float32) {. - importc: "godot_vector2_set_y".} -proc x*(self: Vector2): float32 {. - importc: "godot_vector2_get_x".} -proc y*(self: Vector2): float32 {. - importc: "godot_vector2_get_y".} +proc `<`*(self, other: Vector2): bool {.inline.} = + getGDNativeAPI().vector2OperatorLess(self, other) + +proc `-`*(self: Vector2): Vector2 {.inline.} = + getGDNativeAPI().vector2OperatorNeg(self) diff --git a/godot/core/vector3.nim b/godot/core/vector3.nim index c4c614b..ded30ce 100644 --- a/godot/core/vector3.nim +++ b/godot/core/vector3.nim @@ -1,13 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. import math -import godotbase - -type - Vector3* {.byref.} = object - x*: float32 - y*: float32 - z*: float32 +import godotbase, godotcoretypes proc vec3*(): Vector3 {.inline.} = Vector3() diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim new file mode 100644 index 0000000..c93e5fa --- /dev/null +++ b/godot/gdnativeapi.nim @@ -0,0 +1,1378 @@ +# Copyright 2017 Xored Software, Inc. + +import internal.godotinternaltypes, core.godotcoretypes + +type GDNativeAPI* = object + next: pointer + version: cstring + + # Color API + colorNewRGBA*: proc (dest: var Color, r, g, b, a: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorNewRGB*: proc (dest: var Color, r, g, b: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetR*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetR*: proc (self: var Color, r: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetG*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetG*: proc (self: var Color, g: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetB*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetB*: proc (self: var Color, b: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetA*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetA*: proc (self: var Color, a: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetH*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetS*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetV*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorAsString*: proc (self: Color): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorToRGBA32*: proc (self: Color): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorAsARGB32*: proc (self: Color): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGray*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorInverted*: proc (self: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorContrasted*: proc (self: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorLinearInterpolate*: proc (self, other: Color, t: float32): Color + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + colorBlend*: proc (self, other: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorToHtml*: proc (self: Color, withAlpha: bool): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorOperatorEqual*: proc (self, other: Color): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorOperatorLess*: proc (self, other: Color): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Vector2 API + vector2New*: proc (dest: var Vector2, x, y: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2AsString*: proc (self: Vector2): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Normalized*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Length*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Angle*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2LengthSquared*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2IsNormalized*: proc (self: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2DistanceTo*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2DistanceSquaredTo*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2AngleTo*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2AngleToPoint*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2LinearInterpolate*: proc (self, b: Vector2, t: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2CubicInterpolate*: proc (self, b, preA, postB: Vector2, + t: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2Rotated*: proc (self: Vector2, phi: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Tangent*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Floor*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Snapped*: proc (self, by: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Aspect*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Dot*: proc (self, other: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Slide*: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Bounce*: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Reflect*: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Abs*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Clamped*: proc (self: Vector2, length: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorAdd*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorSubtract*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyVector*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyScalar*: proc (self: Vector2, scalar: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideVector*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideScalar*: proc (self: Vector2, scalar: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorEqual*: proc (self, other: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorLess*: proc (self, other: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorNeg*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2SetX: pointer + vector2SetY: pointer + vector2GetX: pointer + vector2GetY: pointer + + # Quat API + quatNew*: proc (dest: var Quat, x, y, z, w: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatNewWithAxisAngle*: proc (dest: Quat, axis: Vector3, + angle: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetX*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetX*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetY*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetY*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetZ*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetZ*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetW*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetW*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatAsString*: proc (self: Quat): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatLength*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatLengthSquared*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatNormalized*: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatIsNormalized*: proc (self: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatInverse*: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatDot*: proc (self, other: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatXform*: proc (self: Quat, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerp*: proc (self, other: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerpni*: proc (self, other: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatCubicSlerp*: proc (self, other, preA, postB: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorMultiply*: proc (self: Quat, b: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorAdd*: proc (self, other: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorSubtract*: proc (self, other: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorDivide*: proc (self: Quat, divider: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorEqual*: proc (self, other: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorNeg*: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Basis API + basisNewWithRows: pointer + basisNewWithAxisAndAngle: pointer + basisNewWithEuler: pointer + basisAsString: pointer + basisInverse: pointer + basisTransposed: pointer + basisOrthonormalized: pointer + basisDeterminant: pointer + basisRotated: pointer + basisScaled: pointer + basisGetScale: pointer + basisGetEuler: pointer + basisTdotx: pointer + basisTdoty: pointer + basisTdotz: pointer + basisXform: pointer + basisXformInv: pointer + basisGetOrthogonalIndex: pointer + basisNew: pointer + basisNewWithEulerQuat: pointer + basisGetElements: pointer + basisGetAxis: pointer + basisSetAxis: pointer + basisGetRow: pointer + basisSetRow: pointer + basisOperatorEqual: pointer + basisOperatorAdd: pointer + basisOperatorSubstract: pointer + basisOperatorMultiplyVector: pointer + basisOperatorMultiplyScalar: pointer + + # Vector3 API + vector3New: pointer + vector3AsString: pointer + vector3MinAxis: pointer + vector3MaxAxis: pointer + vector3Length: pointer + vector3Length_squared: pointer + vector3IsNormalized: pointer + vector3Normalized: pointer + vector3Inverse: pointer + vector3Snapped: pointer + vector3Rotated: pointer + vector3LinearInterpolate: pointer + vector3CubicInterpolate: pointer + vector3Dot: pointer + vector3Cross: pointer + vector3Outer: pointer + vector3ToDiagonalMatrix: pointer + vector3Abs: pointer + vector3Floor: pointer + vector3Ceil: pointer + vector3DistanceTo: pointer + vector3DistanceSquaredTo: pointer + vector3AngleTo: pointer + vector3Slide: pointer + vector3Bounce: pointer + vector3Reflect: pointer + vector3OperatorAdd: pointer + vector3OperatorSubstract: pointer + vector3OperatorMultiplyVector: pointer + vector3OperatorMultiplyScalar: pointer + vector3OperatorDivideVector: pointer + vector3OperatorDivideScalar: pointer + vector3OperatorEqual: pointer + vector3OperatorLess: pointer + vector3OperatorNeg: pointer + vector3SetAxis: pointer + vector3GetAxis: pointer + + # PoolByteArray API + poolByteArrayNew*: proc (dest: var GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayNewCopy*: proc (dest: var GodotPoolByteArray, + src: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayNewWithArray*: proc (dest: var GodotPoolByteArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolByteArrayAppend*: proc (self: var GodotPoolByteArray, + val: byte) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayAppendArray*: proc (self: var GodotPoolByteArray, + arr: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolByteArrayInsert*: proc (self: var GodotPoolByteArray, + idx: cint, val: byte): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayInvert*: proc (self: var GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayPushBack*: proc (self: var GodotPoolByteArray, val: byte) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolByteArrayRemove*: proc (self: var GodotPoolByteArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayResize*: proc (self: var GodotPoolByteArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArraySet*: proc (self: var GodotPoolByteArray, idx: cint, data: byte) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayGet*: proc (self: GodotPoolByteArray, idx: cint): byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArraySize*: proc (self: GodotPoolByteArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayDestroy*: proc (self: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolIntArray API + poolIntArrayNew*: proc (dest: var GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayNewCopy*: proc (dest: var GodotPoolIntArray, + src: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayNewWithArray*: proc (dest: var GodotPoolIntArray, src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolIntArrayAppend*: proc (self: var GodotPoolIntArray, val: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayAppendArray*: proc (self: var GodotPoolIntArray, + arr: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolIntArrayInsert*: proc (self: var GodotPoolIntArray, idx: cint, + val: cint): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayInvert*: proc (self: var GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayPushBack*: proc (self: var GodotPoolIntArray, val: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayRemove*: proc (self: var GodotPoolIntArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayResize*: proc (self: var GodotPoolIntArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArraySet*: proc (self: var GodotPoolIntArray, idx: cint, data: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayGet*: proc (self: GodotPoolIntArray, idx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArraySize*: proc (self: GodotPoolIntArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayDestroy*: proc (self: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolRealArray API + poolRealArrayNew*: proc (dest: var GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayNewCopy*: proc (dest: var GodotPoolRealArray, + src: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayNewWithArray*: proc (dest: var GodotPoolRealArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayAppend*: proc (self: var GodotPoolRealArray, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayAppendArray*: proc (self: var GodotPoolRealArray, + arr: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayInsert*: proc (self: var GodotPoolRealArray, + idx: cint, val: float32): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayInvert*: proc (self: var GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayPushBack*: proc (self: var GodotPoolRealArray, val: float32) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayRemove*: proc (self: var GodotPoolRealArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayResize*: proc (self: var GodotPoolRealArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArraySet*: proc (self: var GodotPoolRealArray, idx: cint, + data: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayGet*: proc (self: GodotPoolRealArray, idx: cint): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArraySize*: proc (self: GodotPoolRealArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayDestroy*: proc (self: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolStringArray API + poolStringArrayNew*: proc (dest: var GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayNewCopy*: proc (dest: var GodotPoolStringArray, + src: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayNewWithArray*: proc (dest: var GodotPoolStringArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayAppend*: proc (self: var GodotPoolStringArray, + val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayAppendArray*: proc (self: var GodotPoolStringArray, + arr: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayInsert*: proc (self: var GodotPoolStringArray, + idx: cint, val: GodotString): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayInvert*: proc (self: var GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayPushBack*: proc (self: var GodotPoolStringArray, + val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayRemove*: proc (self: var GodotPoolStringArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayResize*: proc (self: var GodotPoolStringArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArraySet*: proc (self: var GodotPoolStringArray, idx: cint, + data: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayGet*: proc (self: GodotPoolStringArray, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArraySize*: proc (self: GodotPoolStringArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayDestroy*: proc (self: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolVector2 API + poolVector2ArrayNew*: proc (dest: var GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayNewCopy*: proc (dest: var GodotPoolVector2Array, + src: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayNewWithArray*: proc (dest: var GodotPoolVector2Array, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayAppend*: proc (self: var GodotPoolVector2Array, val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayAppendArray*: proc (self: var GodotPoolVector2Array, + arr: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayInsert*: proc (self: var GodotPoolVector2Array, idx: cint, + val: Vector2): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayInvert*: proc (self: var GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayPushBack*: proc (self: var GodotPoolVector2Array, + val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayRemove*: proc (self: var GodotPoolVector2Array, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayResize*: proc (self: var GodotPoolVector2Array, size: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArraySet*: proc (self: var GodotPoolVector2Array, idx: cint, + data: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayGet*: proc (self: GodotPoolVector2Array, idx: cint): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArraySize*: proc (self: GodotPoolVector2Array): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayDestroy*: proc (self: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolVector3 API + poolVector3ArrayNew*: proc (dest: var GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayNewCopy*: proc (dest: var GodotPoolVector3Array, + src: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayNewWithArray*: proc (dest: var GodotPoolVector3Array, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayAppend*: proc (self: var GodotPoolVector3Array, val: Vector3) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayAppendArray*: proc (self: var GodotPoolVector3Array, + arr: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayInsert*: proc (self: var GodotPoolVector3Array, idx: cint, + val: Vector3): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayInvert*: proc (self: var GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayPushBack*: proc (self: var GodotPoolVector3Array, + val: Vector3) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayRemove*: proc (self: var GodotPoolVector3Array, + idx: cint) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayResize*: proc (self: var GodotPoolVector3Array, + size: cint) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArraySet*: proc (self: var GodotPoolVector3Array, idx: cint, + data: Vector3) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayGet*: proc (self: GodotPoolVector3Array, idx: cint): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArraySize*: proc (self: GodotPoolVector3Array): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayDestroy*: proc (self: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolColorArray API + poolColorArrayNew*: proc (dest: var GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayNewCopy*: proc (dest: var GodotPoolColorArray, + src: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayNewWithArray*: proc (dest: var GodotPoolColorArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayAppend*: proc (self: var GodotPoolColorArray, + val: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayAppendArray*: proc (self: var GodotPoolColorArray, + arr: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayInsert*: proc (self: var GodotPoolColorArray, + idx: cint, val: Color): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayInvert*: proc (self: var GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayPushBack*: proc (self: var GodotPoolColorArray, val: Color) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayRemove*: proc (self: var GodotPoolColorArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayResize*: proc (self: var GodotPoolColorArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArraySet*: proc (self: var GodotPoolColorArray, idx: cint, + data: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayGet*: proc (self: GodotPoolColorArray, idx: cint): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArraySize*: proc (self: GodotPoolColorArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayDestroy*: proc (self: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Array API + arrayNew*: proc (dest: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewCopy*: proc (dest: var GodotArray, src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewPoolColorArray*: proc (dest: var GodotArray, src: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolVector3Array*: proc (dest: var GodotArray, + src: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolVector2Array*: proc (dest: var GodotArray, + src: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolStringArray*: proc (dest: var GodotArray, + src: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolRealArray*: proc (dest: var GodotArray, src: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolIntArray*: proc (dest: var GodotArray, src: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewPoolByteArray*: proc (dest: var GodotArray, src: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arraySet*: proc (self: var GodotArray, idx: cint, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayGet*: proc (self: GodotArray, idx: cint): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayOperatorIndex*: proc (self: var GodotArray, idx: cint): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayAppend*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayClear*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayCount*: proc (self: GodotArray, val: GodotVariant): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayEmpty*: proc (self: GodotArray): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayErase*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFront*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBack*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFind*: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFindLast*: proc (self: GodotArray, what: GodotVariant): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayHas*: proc (self: GodotArray, val: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayHash*: proc (self: GodotArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayInsert*: proc (self: var GodotArray, pos: cint, val: GodotVariant): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayInvert*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPopFront*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPopBack*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPushBack*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPushFront*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayRemove*: proc (self: var GodotArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayResize*: proc (self: var GodotArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayRFind*: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySize*: proc (self: GodotArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySort*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySortCustom*: proc (self: var GodotArray, obj: ptr GodotObject, + f: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayDestroy*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Dictionary API + dictionaryNew*: proc (dest: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryNewCopy*: proc (dest: var GodotDictionary, src: GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryDestroy*: proc (self: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionarySize*: proc (self: GodotDictionary): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryEmpty*: proc (self: GodotDictionary): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryClear*: proc (self: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHas*: proc (self: GodotDictionary, key: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHasAll*: proc (self: GodotDictionary, keys: GodotArray): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryErase*: proc (self: var GodotDictionary, key: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHash*: proc (self: GodotDictionary): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryKeys*: proc (self: GodotDictionary): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryValues*: proc (self: GodotDictionary): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryGet*: proc (self: GodotDictionary, key: GodotVariant): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionarySet*: proc (self: var GodotDictionary, key, value: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryOperatorIndex*: proc (self: var GodotDictionary, + key: GodotVariant): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + dictionaryNext*: proc (self: GodotDictionary, + key: GodotVariant): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryOperatorEqual*: proc (self, other: GodotDictionary): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + dictionaryToJson*: proc (self: GodotDictionary): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # NodePath API + nodePathNew*: proc (dest: var GodotNodePath, src: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathNewCopy*: proc (dest: var GodotNodePath, src: GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathDestroy*: proc (self: var GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathAsString*: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathIsAbsolute*: proc (self: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetNameCount*: proc (self: GodotNodePath): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetName*: proc (self: GodotNodePath, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetSubnameCount*: proc (self: GodotNodePath): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nodePathGetSubname*: proc (self: GodotNodePath, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetProperty*: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathIsEmpty*: proc (self: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathOperatorEqual*: proc (self, other: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Plane API + planeNewWithReals*: proc (dest: var Plane, a, b, c, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNewWithVectors*: proc (dest: var Plane, v1, v2, v3: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNewWithNormal*: proc (dest: var Plane, normal: Vector3, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeAsString*: proc (self: Plane): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNormalized*: proc (self: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeCenter*: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetAnyPoint*: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIsPointOver*: proc (self: Plane, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeDistanceTo*: proc (self: Plane, point: Vector3): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeHasPoint*: proc (self: Plane, point: Vector3, epsilon: float32): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeProject*: proc (self: Plane, point: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersect3*: proc (self: Plane, dest: var Vector3, b, c: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersectsRay*: proc (self: Plane, dest: var Vector3, + point, dir: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersectsSegment*: proc (self: Plane, dest: var Vector3, + segmentBegin, segmentEnd: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + planeOperatorNeg*: proc (self: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeOperatorEqual*: proc (self, other: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeSetNormal*: proc (self: var Plane, normal: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetNormal*: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetD*: proc (self: Plane): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeSetD*: proc (self: var Plane, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Rect2 API + rect2NewWithPositionAndSize*: proc (dest: var Rect2, pos, size: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect2New*: proc (dest: var Rect2, x, y, width, height: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2AsString*: proc (self: Rect2): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetArea*: proc (self: Rect2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Intersects*: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Encloses*: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2HasNoArea*: proc (self: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Clip*: proc (self, other: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Merge*: proc (self, other: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2HasPoint*: proc (self: Rect2, point: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Grow*: proc (self: Rect2, by: float32): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Expand*: proc (self: Rect2, to: Vector2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2OperatorEqual*: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetPosition*: proc (self: Rect2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetSize*: proc (self: Rect2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2SetPosition*: proc (self: var Rect2, pos: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2SetSize*: proc (self: var Rect2, size: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Rect3 API + rect3New*: proc (dest: var Rect3, pos, size: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetPosition*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3SetPosition*: proc (self: var Rect3, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetSize*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3SetSize*: proc (self: var Rect3, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3AsString*: proc (self: Rect3): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetArea*: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3HasNoArea*: proc (self: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3HasNoSurface*: proc (self: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Intersects*: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Encloses*: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Merge*: proc (self, other: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Intersection*: proc (self, other: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3IntersectsPlane*: proc (self: Rect3, plane: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3IntersectsSegment*: proc (self: Rect3, vFrom, vTo: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3HasPoint*: proc (self: Rect3, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetSupport*: proc (self: Rect3, dir: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetLongestAxis*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetLongestAxisIndex*: proc (self: Rect3): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetLongestAxisSize*: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetShortestAxis*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetShortestAxisIndex*: proc (self: Rect3): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetShortestAxisSize*: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3Expand*: proc (self: Rect3, toPoint: Vector3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Grow*: proc (self: Rect3, by: float32): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetEndpoint*: proc (self: Rect3, idx: cint): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3OperatorEqual*: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # RID API + ridNew*: proc (dest: var RID) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridGetID*: proc (self: RID): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridNewWithResource*: proc (dest: var RID, obj: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridOperatorEqual*: proc (self, other: RID): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridOperatorLess*: proc (self, other: RID): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Transform API + transformNewWithAxisOrigin*: proc (dest: var Transform, + xAxis, yAxis, zAxis, origin: Vector3) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformNew*: proc (dest: var Transform, basis: Basis, origin: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformGetBasis*: proc (self: Transform): Basis + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetBasis*: proc (self: var Transform, basis: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformGetOrigin*: proc (self: Transform): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetOrigin*: proc (self: var Transform, v: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAsString*: proc (self: Transform): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformInverse*: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAffineInverse*: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOrthonormalized*: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformRotated*: proc (self: Transform, axis: Vector3, + phi: float32): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformScaled*: proc (self: Transform, scale: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformTranslated*: proc (self: Transform, offset: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformLookingAt*: proc (self: Transform, target, up: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformPlane*: proc (self: Transform, plane: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvPlane*: proc (self: Transform, plane: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformNewIdentity*: proc (dest: var Transform) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformOperatorEqual*: proc (self, other: Transform): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOperatorMultiply*: proc (self, other: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformVector3*: proc (self: Transform, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformRect3*: proc (self: Transform, v: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvRect3*: proc (self: Transform, v: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Transform2D API + transform2DNew*: proc (dest: var Transform2D, rot: float32, pos: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DNewAxisOrigin*: proc (dest: var Transform2D, + xAxis, yAxis, origin: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DAsString*: proc (self: Transform2D): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DInverse*: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DAffineInverse*: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DGetRotation*: proc (self: Transform2D): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DGetOrigin*: proc (self: Transform2D): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DGetScale*: proc (self: Transform2D): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DOrthonormalized*: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DRotated*: proc (self: Transform2D, phi: float32): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DScaled*: proc (self: Transform2D, scale: Vector2): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DTranslated*: proc (self: Transform2D, offset: Vector2): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvVector2*: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformInvVector2*: proc (self: Transform2D, + v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DInterpolateWith*: proc (self, other: Transform2D, + t: float32): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DOperatorEqual*: proc (self, other: Transform2D): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DOperatorMultiply*: proc (self, other: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DNewIdentity*: proc (dest: var Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformRect2*: proc (self: Transform2D, v: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvRect2*: proc (self: Transform2D, v: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Variant API + variantGetType*: proc (v: GodotVariant): VariantType + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewCopy*: proc (dest: var GodotVariant, src: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewNil*: proc (dest: var GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewBool*: proc (dest: var GodotVariant, val: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewUInt*: proc (dest: var GodotVariant, val: uint64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewInt*: proc (dest: var GodotVariant, val: int64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewReal*: proc (dest: var GodotVariant, val: float64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewString*: proc (dest: var GodotVariant, val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewVector2*: proc (dest: var GodotVariant, val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRect2*: proc (dest: var GodotVariant, val: Rect2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewVector3*: proc (dest: var GodotVariant, val: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewTransform2D*: proc (dest: var GodotVariant, val: Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPlane*: proc (dest: var GodotVariant, val: Plane) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewQuat*: proc (dest: var GodotVariant, val: Quat) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRect3*: proc (dest: var GodotVariant, val: Rect3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewBasis*: proc (dest: var GodotVariant, val: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewTransform*: proc (dest: var GodotVariant, val: Transform) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewColor*: proc (dest: var GodotVariant, val: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewNodePath*: proc (dest: var GodotVariant, val: GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRID*: proc (dest: var GodotVariant, val: RID) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewObject*: proc (dest: var GodotVariant, val: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewDictionary*: proc (dest: var GodotVariant, val: GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewArray*: proc (dest: var GodotVariant, val: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewPoolByteArray*: proc (dest: var GodotVariant, + val: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolIntArray*: proc (dest: var GodotVariant, val: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolRealArray*: proc (dest: var GodotVariant, + val: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolStringArray*: proc (dest: var GodotVariant, + val: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolVector2Array*: proc (dest: var GodotVariant, + val: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolVector3Array*: proc (dest: var GodotVariant, + val: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolColorArray*: proc (dest: var GodotVariant, + val: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsBool*: proc (self: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsUInt*: proc (self: GodotVariant): uint64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsInt*: proc (self: GodotVariant): int64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsReal*: proc (self: GodotVariant): float64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsString*: proc (self: GodotVariant): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector2*: proc (self: GodotVariant): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect2*: proc (self: GodotVariant): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector3*: proc (self: GodotVariant): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform2D*: proc (self: GodotVariant): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPlane*: proc (self: GodotVariant): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsQuat*: proc (self: GodotVariant): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect3*: proc (self: GodotVariant): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsBasis*: proc (self: GodotVariant): Basis + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform*: proc (self: GodotVariant): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsColor*: proc (self: GodotVariant): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsNodePath*: proc (self: GodotVariant): GodotNodePath + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRID*: proc (self: GodotVariant): RID + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsObject*: proc (self: GodotVariant): ptr GodotObject + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsDictionary*: proc (self: GodotVariant): GodotDictionary + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsArray*: proc (self: GodotVariant): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPoolByteArray*: proc (self: GodotVariant): GodotPoolByteArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolIntArray*: proc (self: GodotVariant): GodotPoolIntArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolRealArray*: proc (self: GodotVariant): GodotPoolRealArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolStringArray*: proc (self: GodotVariant): GodotPoolStringArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolVector2Array*: proc (self: GodotVariant): GodotPoolVector2Array + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolVector3Array*: proc (self: GodotVariant): GodotPoolVector3Array + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolColorArray*: proc (self: GodotVariant): GodotPoolColorArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantCall*: proc (self: var GodotVariant, meth: GodotString, + args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], + argcount: cint, + callError: var VariantCallError): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantHasMethod*: proc (self: GodotVariant, meth: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantOperatorEqual*: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantOperatorLess*: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantHashCompare*: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantBooleanize*: proc (self: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantDestroy*: proc (self: var GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # String API + stringNew*: proc (dest: var GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewCopy*: proc (dest: var GodotString, src: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewData*: proc (dest: var GodotString, contents: cstring, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewUTF16Data: pointer + stringGetData*: proc (self: GodotString, dest: cstring, size: var cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorIndex: pointer + stringCStr*: proc (self: GodotString): cstring + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringUTF16Str: pointer + stringOperatorEqual*: proc (self, other: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorLess*: proc (self, other: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorPlus*: proc (self, other: GodotString): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringLength*: proc (self: GodotString): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringBeginsWith: pointer + stringBeginsWithCharArray: pointer + stringBigrams: pointer + stringChr: pointer + stringEndsWith: pointer + stringFind: pointer + stringFindFrom: pointer + stringFindmk: pointer + stringFindmkFrom: pointer + stringFindmkFromInPlace: pointer + stringFindn: pointer + stringFindnFrom: pointer + stringFindLast: pointer + stringFormat: pointer + stringFormatWithCustomPlaceholder: pointer + stringHexEncodeBuffer: pointer + stringHexToInt: pointer + stringHexToIntWithoutPrefix: pointer + stringInsert: pointer + stringIsNumeric: pointer + stringIsSubsequenceOf: pointer + stringIsSubsequenceOfi: pointer + stringLpad: pointer + stringLpadWithCustomCharacter: pointer + stringMatch: pointer + stringMatchn: pointer + stringMd5: pointer + stringNum: pointer + stringNumInt64: pointer + stringNumInt64Capitalized: pointer + stringNumReal: pointer + stringNumScientific: pointer + stringNumWithDecimals: pointer + stringPadDecimals: pointer + stringPadZeros: pointer + stringReplaceFirst: pointer + stringReplace: pointer + stringReplacen: pointer + stringRfind: pointer + stringRfindn: pointer + stringRfindFrom: pointer + stringRfindnFrom: pointer + stringRpad: pointer + stringRpadWithCustomCharacter: pointer + stringSimilarity: pointer + stringSprintf: pointer + stringSubstr: pointer + stringToDouble: pointer + stringToFloat: pointer + stringToInt: pointer + stringCamelcaseToUnderscore: pointer + stringCamelcaseToUnderscoreLowercased: pointer + stringCapitalize: pointer + stringCharToDouble: pointer + stringCharToInt: pointer + stringWcharToInt: pointer + stringCharToIntWithLen: pointer + stringCharToInt64WithLen: pointer + stringHexToInt64: pointer + stringHexToInt64WithPrefix: pointer + stringToInt64: pointer + stringUnicodeCharToDouble: pointer + stringGetSliceCount: pointer + stringGetSlice: pointer + stringGetSlicec: pointer + stringSplit: pointer + stringSplitAllowEmpty: pointer + stringSplitFloats: pointer + stringSplitFloatsAllowsEmpty: pointer + stringSplitFloatsMk: pointer + stringSplitFloatsMkAllowsEmpty: pointer + stringSplitInts: pointer + stringSplitIntsAllowsEmpty: pointer + stringSplitIntsMk: pointer + stringSplitIntsMkAllowsEmpty: pointer + stringSplitSpaces: pointer + stringCharLowercase: pointer + stringCharUppercase: pointer + stringToLower: pointer + stringToUpper: pointer + stringGetBasename: pointer + stringGetExtension: pointer + stringLeft: pointer + stringOrdAt: pointer + stringPlusFile: pointer + stringRight: pointer + stringStripEdges: pointer + stringStripEscapes: pointer + stringErase: pointer + stringAscii: pointer + stringAsciiExtended: pointer + stringUtf8: pointer + stringParseUtf8: pointer + stringParseUtf8WithLen: pointer + stringCharsToUtf8: pointer + stringCharsToUtf8WithLen: pointer + stringHash: pointer + stringHash64: pointer + stringHashChars: pointer + stringHashCharsWithLen: pointer + stringHashUtf8Chars: pointer + stringHashUtf8CharsWithLen: pointer + stringMd5Buffer: pointer + stringMd5Text: pointer + stringSha256Buffer: pointer + stringSha256Text: pointer + stringEmpty: pointer + stringGetBaseDir: pointer + stringGetFile: pointer + stringHumanizeSize: pointer + stringIsAbsPath: pointer + stringIsRelPath: pointer + stringIsResourceFile: pointer + stringPathTo: pointer + stringPathToFile: pointer + stringSimplifyPath: pointer + stringCEscape: pointer + stringCEscapeMultiline: pointer + stringCUnescape: pointer + stringHttpEscape: pointer + stringHttpUnescape: pointer + stringJsonEscape: pointer + stringWordWrap: pointer + stringXmlEscape: pointer + stringXmlEscapeWithQuotes: pointer + stringXmlUnescape: pointer + stringPercentDecode: pointer + stringPercentEncode: pointer + stringIsValidFloat: pointer + stringIsValidHexNumber: pointer + stringIsValidHtmlColor: pointer + stringIsValidIdentifier: pointer + stringIsValidInteger: pointer + stringIsValidIpAddress: pointer + stringDestroy*: proc (self: var GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Misc API + objectDestroy*: proc (self: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + globalGetSingleton*: proc (name: cstring): ptr GodotObject + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindGetMethod*: proc (className, + methodName: cstring): ptr GodotMethodBind + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindPtrCall*: proc (methodBind: ptr GodotMethodBind, + obj: ptr GodotObject, + args: ptr array[MAX_ARG_COUNT, pointer], + ret: pointer) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindCall*: proc (methodBind: ptr GodotMethodBind, obj: ptr GodotObject, + args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], + argCount: cint, + callError: var VariantCallError): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + getClassConstructor*: proc (className: cstring): GodotClassConstructor + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + alloc*: proc (bytes: cint): pointer + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + realloc*: proc (p: pointer, bytes: cint): pointer + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + free*: proc (p: pointer) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + printError*: proc (description, function, file: cstring, line: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + printWarning*: proc (description, function, file: cstring, line: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + print*: proc (message: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # NativeScript API + nativeScriptRegisterClass*: proc (gdnativeHandle: pointer, + name, base: cstring, + createFunc: GodotInstanceCreateFunc, + destroyFunc: GodotInstanceDestroyFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterToolClass*: proc (gdnativeHandle: pointer, + name, base: cstring, + createFunc: GodotInstanceCreateFunc, + destroyFunc: GodotInstanceDestroyFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterMethod*: proc (gdnativeHandle: pointer, + name, functionName: cstring, + attr: GodotMethodAttributes, + meth: GodotInstanceMethod) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterProperty*: proc (gdnativeHandle: pointer, + name, path: cstring, + attr: ptr GodotPropertyAttributes, + setFunc: GodotPropertySetFunc, + getFunc: GodotPropertyGetFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterSignal*: proc (gdnativeHandle: pointer, name: cstring, + signal: GodotSignal) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptGetUserdata*: proc (obj: ptr GodotObject): pointer + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + +var gdNativeAPI: ptr GDNativeAPI + +proc getGDNativeAPI*(): ptr GDNativeAPI {.inline.} = + gdNativeAPI + +proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = + gdNativeAPI = cast[ptr GDNativeAPI](apiStruct) diff --git a/godot/godot.nim b/godot/godot.nim index eb38a58..bab24f7 100644 --- a/godot/godot.nim +++ b/godot/godot.nim @@ -1,6 +1,7 @@ # Copyright 2017 Xored Software, Inc. import core.godotbase, godotinternal +import core.godotcoretypes import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes, core.quats import core.rect3, core.basis, core.transforms, core.colors, core.nodepaths, @@ -9,9 +10,9 @@ import core.dictionaries, core.arrays, core.poolarrays, core.variants import nim.godotmacros, nim.godotnim -export godotbase, vector2, rect2, vector3, transform2d, planes, quats, - rect3, basis, transforms, colors, nodepaths, rids, dictionaries, arrays, - poolarrays, variants +export godotbase, godotcoretypes, vector2, rect2, vector3, transform2d, planes, + quats, rect3, basis, transforms, colors, nodepaths, rids, dictionaries, + arrays, poolarrays, variants export godotmacros, godotnim export GodotPropertyHint, GodotPropertyUsage \ No newline at end of file diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index c241d77..c89ea6c 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -1,259 +1,87 @@ # Copyright 2017 Xored Software, Inc. -import internal.godotobjects, internal.godotarrays, internal.godotnodepaths, - internal.godotpoolarrays, internal.godotstrings, internal.godotvariants, - internal.godotdictionaries +import internal.godotinternaltypes, internal.godotarrays, + internal.godotnodepaths, internal.godotpoolarrays, internal.godotstrings, + internal.godotvariants, internal.godotdictionaries -export godotobjects, godotarrays, godotnodepaths, godotpoolarrays, +import gdnativeapi +export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays, godotstrings, godotvariants, godotdictionaries -const MAX_ARG_COUNT* = 128 +proc getMethod*(className: cstring; + methodName: cstring): ptr GodotMethodBind {.inline.} = + getGDNativeAPI().methodBindGetMethod(className, methodName) -# MethodBind API - -type GodotMethodBind* = object - -proc getMethod*(className: cstring; methodName: cstring): ptr GodotMethodBind {. - importc: "godot_method_bind_get_method".} proc ptrCall*(methodBind: ptr GodotMethodBind; instance: ptr GodotObject; args: ptr array[MAX_ARG_COUNT, pointer]; - ret: pointer) {. - importc: "godot_method_bind_ptrcall".} + ret: pointer) {.inline.} = + getGDNativeAPI().methodBindPtrCall(methodBind, instance, args, ret) + proc call*(methodBind: ptr GodotMethodBind; instance: ptr GodotObject; args: ptr array[MAX_ARG_COUNT, ptr GodotVariant]; argCount: cint; - callError: var VariantCallError): GodotVariant {. - importc: "godot_method_bind_call".} + callError: var VariantCallError): GodotVariant {.inline.} = + getGDNativeAPI().methodBindCall( + methodBind, instance, args, argCount, callError) -# Script API +proc nativeScriptRegisterClass*(libHandle: pointer; name, base: cstring; + createFunc: GodotInstanceCreateFunc; + destroyFunc: GodotInstanceDestroyFunc) + {.inline.} = + let api = getGDNativeAPI() + api.nativeScriptRegisterClass( + libHandle, name, base, createFunc, destroyFunc) -type - GodotNativeInitOptions* = object - inEditor*: bool - coreApiHash*: uint64 - editorApiHash*: uint64 - noApiHash*: uint64 - gdNativeLibrary*: ptr GodotObject +proc nativeScriptRegisterToolClass*(libHandle: pointer; name, base: cstring; + createFunc: GodotInstanceCreateFunc; + destroyFunc: GodotInstanceDestroyFunc) + {.inline.} = + getGDNativeAPI().nativeScriptRegisterToolClass( + libHandle, name, base, createFunc, destroyFunc) - GodotNativeTerminateOptions* = object - inEditor*: bool +proc nativeScriptRegisterMethod*(libHandle: pointer; + name: cstring; function_name: cstring; + attr: GodotMethodAttributes; + meth: GodotInstanceMethod) {.inline.} = + getGDNativeAPI().nativeScriptRegisterMethod( + libHandle, name, functionName, attr, meth) - GodotMethodRPCMode* {.size: sizeof(cint), pure.} = enum - Disabled, - Remote, - Sync, - Master, - Slave +proc nativeScriptRegisterProperty*(libHandle: pointer; + name, path: cstring; + attr: ptr GodotPropertyAttributes; + setFunc: GodotPropertySetFunc; + getFunc: GodotPropertyGetFunc) {.inline.} = + getGDNativeAPI().nativeScriptRegisterProperty( + libHandle, name, path, attr, setFunc, getFunc) - GodotMethodAttributes* = object - rpcMode*: GodotMethodRPCMode +proc nativeScriptRegisterSignal*(libHandle: pointer; name: cstring; + signal: GodotSignal) {.inline.} = + getGDNativeAPI().nativeScriptRegisterSignal(libHandle, name, signal) - GodotPropertyHint* {.size: sizeof(cint), pure.} = enum - None, ## no hint provided. - Range, ## hint_text = "min,max,step,slider; // slider is optional" - ExpRange, ## hint_text = "min,max,step", exponential edit - Enum, ## hint_text= "val1,val2,val3,etc" - ExpEasing, ## exponential easing funciton (Math::ease) - Length, ## hint_text= "length" (as integer) - SpriteFrame, - KeyAccel, ## hint_text= "length" (as integer) - Flags, ## hint_text= "flag1,flag2,etc" (as bit flags) - Layers2DRender, - Layers2DPhysics, - Layers3DRender, - Layers3DPhysics, - File, ## a file path must be passed, hint_text (optionally) - ## is a filter "*.png,*.wav,*.doc," - Dir, ## a directort path must be passed - GlobalFile, ## a file path must be passed, hint_text (optionally) is a - ## filter "*.png,*.wav,*.doc," - GlobalDir, ## a directort path must be passed - ResourceType, ## a resource object type - MultilineText, ## used for string properties that can contain multiple lines - ColorNoAlpha, ## used for ignoring alpha component when editing a color - ImageCompressLossy, - ImageCompressLossless, - ObjectId, - TypeString, ## a type string, the hint is the base type to choose - NodePathToEditedNode, ## so something else can provide this - ## (used in scripts) - MethodOfVariantType, ## a method of a type - MethodOfBaseType, ## a method of a base type - MethodOfInstance, ## a method of an instance - MethodOfScript, ## a method of a script & base - PropertyOfVariantType, ## a property of a type - PropertyOfBaseType, ## a property of a base type - PropertyOfInstance, ## a property of an instance - PropertyOfScript, ## a property of a script & base - PropertyHintMax +proc getUserdata*(instance: ptr GodotObject): pointer {.inline.} = + getGDNativeAPI().nativeScriptGetUserdata(instance) -const - GODOT_PROPERTY_USAGE_STORAGE_VALUE = 1.cint - GODOT_PROPERTY_USAGE_EDITOR_VALUE = 2.cint - GODOT_PROPERTY_USAGE_NETWORK_VALUE = 4.cint - GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE = 8.cint - GODOT_PROPERTY_USAGE_CHECKABLE_VALUE = 16.cint - GODOT_PROPERTY_USAGE_CHECKED_VALUE = 32.cint - GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE = 64.cint - GODOT_PROPERTY_USAGE_GROUP_VALUE = 128.cint - GODOT_PROPERTY_USAGE_CATEGORY_VALUE = 256.cint - GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE = 512.cint - GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE = 1024.cint - GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE = 2048.cint - GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE = 4096.cint - GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE = 8192.cint - GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE = 16384.cint - GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE = 32768.cint - GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE = 65536.cint +proc getClassConstructor*(className: cstring): GodotClassConstructor + {.inline.} = + getGDNativeAPI().getClassConstructor(className) - GODOT_PROPERTY_USAGE_DEFAULT_VALUE: cint = - GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_EDITOR_VALUE or - GODOT_PROPERTY_USAGE_NETWORK_VALUE - GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE: cint = - GODOT_PROPERTY_USAGE_STORAGE_VALUE or - GODOT_PROPERTY_USAGE_EDITOR_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE or - GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE - GODOT_PROPERTY_USAGE_NOEDITOR_VALUE: cint = - GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE - -type - GodotPropertyUsage* {.size: sizeof(cint), pure.} = enum - Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE - Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE - Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE - NoEditor = GODOT_PROPERTY_USAGE_NOEDITOR_VALUE - Default = GODOT_PROPERTY_USAGE_DEFAULT_VALUE - EditorHelper = GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE - Checkable = GODOT_PROPERTY_USAGE_CHECKABLE_VALUE - ## used for editing global variables - Checked = GODOT_PROPERTY_USAGE_CHECKED_VALUE - ## used for editing global variables - Internationalized = GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE - ## hint for internationalized strings - DefaultIntl = GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE - Group = GODOT_PROPERTY_USAGE_GROUP_VALUE - ## used for grouping props in the editor - Category = GODOT_PROPERTY_USAGE_CATEGORY_VALUE - NonZero = GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE - ## only store if nonzero - NonOne = GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE - ## only store if false - NoInstanceState = GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE - RestartIfChanged = GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE - ScriptVariable = GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE - StoreIfNull = GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE - AnimateAsTrigger = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE - UpdateAllIfModified = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE - - GodotPropertyAttributes* {.bycopy.} = object - rsetType*: GodotMethodRPCMode - typ*: cint - hint*: GodotPropertyHint - hintString*: GodotString - usage*: cint - defaultValue*: GodotVariant - - GodotInstanceCreateFunc* {.bycopy.} = object - createFunc*: - proc (obj: ptr GodotObject; methodData: pointer): pointer {.noconv.} - ## returns user data - methodData*: pointer - freeFunc*: proc (a2: pointer) {.noconv.} - - GodotInstanceDestroyFunc* {.bycopy.} = object - destroyFunc*: - proc (obj: ptr GodotObject; methodData: pointer; - userData: pointer) {.noconv.} - methodData*: pointer - freeFunc*: proc (a2: pointer) {.noconv.} - -proc godotScriptRegisterClass*(libHandle: pointer; name, base: cstring; - create_func: GodotInstanceCreateFunc; - destroy_func: GodotInstanceDestroyFunc) {. - importc: "godot_nativescript_register_class".} -proc godotScriptRegisterToolClass*(libHandle: pointer; name, base: cstring; - createFunc: GodotInstanceCreateFunc; - destroyFunc: GodotInstanceDestroyFunc) {. - importc: "godot_nativescript_register_tool_class".} -type - GodotInstanceMethod* {.bycopy.} = object - meth*: - proc (obj: ptr GodotObject; methodData: pointer; - userData: pointer; numArgs: cint; - args: var array[MAX_ARG_COUNT, ptr GodotVariant]): - GodotVariant {.noconv.} - methodData*: pointer - freeFunc*: proc (a2: pointer) {.noconv.} - -proc godotScriptRegisterMethod*(libHandle: pointer; - name: cstring; function_name: cstring; - attr: GodotMethodAttributes; - meth: GodotInstanceMethod) {. - importc: "godot_nativescript_register_method".} -type - GodotPropertySetFunc* {.bycopy.} = object - setFunc*: proc (obj: ptr GodotObject; methodData: pointer; - userData: pointer; value: GodotVariant) {.noconv.} - methodData*: pointer - freeFunc*: proc (a2: pointer) {.noconv.} - - GodotPropertyGetFunc* {.bycopy.} = object - getFunc*: proc (obj: ptr GodotObject; methodData: pointer; - userData: pointer): GodotVariant {.noconv.} - methodData*: pointer - freeFunc*: proc (a2: pointer) {.noconv.} - -proc godotScriptRegisterProperty*(libHandle: pointer; - name: cstring; path: cstring; - attr: ptr GodotPropertyAttributes; - setFunc: GodotPropertySetFunc; - getFunc: GodotPropertyGetFunc) {. - importc: "godot_nativescript_register_property".} - -type - GodotSignalArgument* {.bycopy.} = object - name*: GodotString - typ*: cint - hint*: GodotPropertyHint - hintString*: GodotString - usage*: cint - defaultValue*: GodotVariant - - GodotSignal* = object - name*: GodotString - numArgs*: cint - args*: ptr GodotSignalArgument - numDefaultArgs*: cint - defaultArgs*: ptr GodotVariant - - -proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring; - signal: GodotSignal) {. - importc: "godot_nativescript_register_signal".} - -proc getUserdata*(instance: ptr GodotObject): pointer {. - importc: "godot_nativescript_get_userdata".} - -type ClassConstructor = proc (): ptr GodotObject {.noconv.} -proc getClassConstructor*(className: cstring): ClassConstructor {. - importc: "godot_get_class_constructor".} - -proc deinit*(o: ptr GodotObject) {. - importc: "godot_object_destroy".} +proc deinit*(o: ptr GodotObject) {.inline.} = + getGDNativeAPI().objectDestroy(o) # print using Godot's error handler list -proc godotPrintError*(description: cstring; function: cstring; file: cstring; - line: cint) {. - importc: "godot_print_error".} +proc godotPrintError*(description, function, file: cstring; + line: cint) {.inline.} = + let api = getGDNativeAPI() + api.printError(description, function, file, line) -proc godotPrintWarning*(description: cstring; function: cstring; - file: cstring; line: cint) {. - importc: "godot_print_warning".} +proc godotPrintWarning*(description, function, file: cstring; + line: cint) {.inline.} = + getGDNativeAPI().printWarning(description, function, file, line) -proc godotPrint*(message: GodotString) {. - importc: "godot_print".} +proc godotPrint*(message: GodotString) {.inline.} = + getGDNativeAPI().print(message) var getClassMethodBind: ptr GodotMethodBind proc getClassName*(o: ptr GodotObject): string = @@ -267,22 +95,25 @@ proc getClassName*(o: ptr GodotObject): string = # There are physics type not known by ClassDB result = result[0..result.len-3] -proc getGodotSingleton*(name: cstring): ptr GodotObject {. - importc: "godot_global_get_singleton".} +proc getGodotSingleton*(name: cstring): ptr GodotObject {.inline.} = + getGDNativeAPI().globalGetSingleton(name) # System Functions -proc godotAlloc*(bytes: cint): pointer {. - importc: "godot_alloc".} +proc godotAlloc*(bytes: cint): pointer {.inline.} = ## Allocates the specified number of bytes. ## Using this instead of stdlib proc will help Godot track how much memory ## is in use in debug mode. -proc godotRealloc*(p: pointer; bytes: cint): pointer {. - importc: "godot_realloc".} + getGDNativeAPI().alloc(bytes) + +proc godotRealloc*(p: pointer; bytes: cint): pointer {.inline.} = ## Reallocates the pointer for the specified number of bytes. ## Using this instead of stdlib proc will help Godot track how much memory ## is in use in debug mode. -proc godotFree*(p: pointer) {.importc: "godot_free".} + getGDNativeAPI().realloc(p, bytes) + +proc godotFree*(p: pointer) {.inline.} = ## Frees the memory pointed to by the pointer. ## Using this instead of stdlib proc will help Godot track how much memory ## is in use in debug mode. + getGDNativeAPI().free(p) diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index d6ee910..676e6cd 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -1,107 +1,130 @@ # Copyright (c) 2017 Xored Software, Inc. -type - GodotArray* {.byref.} = object - data: array[sizeof(int), byte] +import godotinternaltypes, gdnativeapi, core.godotcoretypes -proc len*(self: GodotArray): cint {. - noSideEffect, - importc: "godot_array_size".} +proc len*(self: GodotArray): cint {.inline.} = + getGDNativeAPI().arraySize(self) import hashes -import godotobjects, godotpoolarrays, godotvariants, godotstrings -proc initGodotArray*(dest: var GodotArray) {. - importc: "godot_array_new".} -proc initGodotArray*(dest: var GodotArray; pca: GodotPoolColorArray) {. - importc: "godot_array_new_pool_coloarray".} -proc initGodotArray*(dest: var GodotArray; pv3a: GodotPoolVector3Array) {. - importc: "godot_array_new_pool_vector3_array".} -proc initGodotArray*(dest: var GodotArray; pv2a: GodotPoolVector2Array) {. - importc: "godot_array_new_pool_vector2_array".} -proc initGodotArray*(dest: var GodotArray; psa: GodotPoolStringArray) {. - importc: "godot_array_new_pool_string_array".} -proc initGodotArray*(dest: var GodotArray; pra: GodotPoolRealArray) {. - importc: "godot_array_new_pool_real_array".} -proc initGodotArray*(dest: var GodotArray; pia: GodotPoolIntArray) {. - importc: "godot_array_new_pool_int_array".} -proc initGodotArray*(dest: var GodotArray; pba: GodotPoolByteArray) {. - importc: "godot_array_new_pool_byte_array".} -proc iniGodotArray*(dest: var GodotArray; src: GodotArray) {. - importc: "godot_array_new_copy".} +proc initGodotArray*(dest: var GodotArray) {.inline.} = + getGDNativeAPI().arrayNew(dest) -proc deinit*(self: var GodotArray) {.importc: "godot_array_destroy".} +proc initGodotArray*(dest: var GodotArray; + pca: GodotPoolColorArray) {.inline.} = + getGDNativeAPI().arrayNewPoolColorArray(dest, pca) -proc `[]=`*(self: var GodotArray; idx: cint; - value: GodotVariant) {. - noSideEffect, - importc: "godot_array_set".} -proc `[]`*(self: GodotArray; idx: cint): GodotVariant {. - noSideEffect, - importc: "godot_array_get".} -proc mget*(self: var GodotArray; idx: cint): ptr GodotVariant {. - importc: "godot_array_operator_index".} +proc initGodotArray*(dest: var GodotArray; + pv3a: GodotPoolVector3Array) {.inline.} = + getGDNativeAPI().arrayNewPoolVector3Array(dest, pv3a) + +proc initGodotArray*(dest: var GodotArray; + pv2a: GodotPoolVector2Array) {.inline.} = + getGDNativeAPI().arrayNewPoolVector2Array(dest, pv2a) + +proc initGodotArray*(dest: var GodotArray; + psa: GodotPoolStringArray) {.inline.} = + getGDNativeAPI().arrayNewPoolStringArray(dest, psa) + +proc initGodotArray*(dest: var GodotArray; + pra: GodotPoolRealArray) {.inline.} = + getGDNativeAPI().arrayNewPoolRealArray(dest, pra) + +proc initGodotArray*(dest: var GodotArray; + pia: GodotPoolIntArray) {.inline.} = + getGDNativeAPI().arrayNewPoolIntArray(dest, pia) + +proc initGodotArray*(dest: var GodotArray; + pba: GodotPoolByteArray) {.inline.} = + getGDNativeAPI().arrayNewPoolByteArray(dest, pba) + +proc initGodotArray*(dest: var GodotArray; src: GodotArray) {.inline.} = + getGDNativeAPI().arrayNewCopy(dest, src) + +proc deinit*(self: var GodotArray) {.inline.} = + getGDNativeAPI().arrayDestroy(self) + +proc `[]=`*(self: var GodotArray; idx: cint; value: GodotVariant) {.inline.} = + getGDNativeAPI().arraySet(self, idx, value) + +proc `[]`*(self: GodotArray; idx: cint): GodotVariant {.inline.} = + getGDNativeAPI().arrayGet(self, idx) + +proc mget*(self: var GodotArray; idx: cint): ptr GodotVariant {.inline.} = + getGDNativeAPI().arrayOperatorIndex(self, idx) + +proc add*(self: var GodotArray; value: GodotVariant) {.inline.} = + getGDNativeAPI().arrayPushBack(self, value) + +proc clear*(self: var GodotArray) {.inline.} = + getGDNativeAPI().arrayClear(self) + +proc count*(self: GodotArray; value: GodotVariant): cint {.inline.} = + getGDNativeAPI().arrayCount(self, value) + +proc isEmpty*(self: GodotArray): bool {.inline.} = + getGDNativeAPI().arrayEmpty(self) + +proc erase*(self: var GodotArray; value: GodotVariant) {.inline.} = + getGDNativeAPI().arrayErase(self, value) + +proc first*(self: GodotArray): GodotVariant {.inline.} = + getGDNativeAPI().arrayFront(self) + +proc last*(self: GodotArray): GodotVariant {.inline.} = + getGDNativeAPI().arrayBack(self) -proc add*(self: var GodotArray; value: GodotVariant) {. - noSideEffect, - importc: "godot_array_append".} -proc clear*(self: var GodotArray) {.importc: "godot_array_clear".} -proc count*(self: GodotArray; value: GodotVariant): cint {. - noSideEffect, - importc: "godot_array_count".} -proc isEmpty*(self: GodotArray): bool {. - noSideEffect, - importc: "godot_array_empty".} -proc erase*(self: var GodotArray; value: GodotVariant) {. - importc: "godot_array_erase".} -proc first*(self: GodotArray): GodotVariant {. - noSideEffect, - importc: "godot_array_front".} -proc last*(self: GodotArray): GodotVariant {. - noSideEffect, - importc: "godot_array_back".} proc find*(self: GodotArray; what: GodotVariant; - f: cint): cint {. - noSideEffect, - importc: "godot_array_find".} -proc findLast*(self: GodotArray; what: GodotVariant): cint {. - noSideEffect, - importc: "godot_array_find_last".} -proc contains*(self: GodotArray; value: GodotVariant): bool {. - noSideEffect, - importc: "godot_array_has".} + fromIdx: cint): cint {.inline.} = + getGDNativeAPI().arrayFind(self, what, fromIdx) + +proc findLast*(self: GodotArray; what: GodotVariant): cint {.inline.} = + getGDNativeAPI().arrayFindLast(self, what) + +proc contains*(self: GodotArray; value: GodotVariant): bool {.inline.} = + getGDNativeAPI().arrayHas(self, value) + +proc godotHash*(self: GodotArray): cint {.inline.} = + getGDNativeAPI().arrayHash(self) -proc godotHash*(self: GodotArray): cint {. - noSideEffect, - importc: "godot_array_hash".} proc hash*(self: GodotArray): Hash {.inline.} = hash(godotHash(self)) proc insert*(self: var GodotArray; pos: cint; - value: GodotVariant) {. - importc: "godot_array_insert".} -proc reverse*(self: var GodotArray) {.importc: "godot_array_invert".} -proc popLast*(self: var GodotArray): GodotVariant {. - importc: "godot_array_pop_back".} -proc popFirst*(self: var GodotArray): GodotVariant {. - importc: "godot_array_pop_front".} -proc addLast*(self: var GodotArray; value: GodotVariant) {. - importc: "godot_array_push_back".} -proc addFirst*(self: var GodotArray; value: GodotVariant) {. - importc: "godot_array_push_front".} + value: GodotVariant): Error {.discardable, inline.} = + getGDNativeAPI().arrayInsert(self, pos, value) + +proc reverse*(self: var GodotArray) {.inline.} = + getGDNativeAPI().arrayInvert(self) + +proc popLast*(self: var GodotArray): GodotVariant {.inline.} = + getGDNativeAPI().arrayPopBack(self) + +proc popFirst*(self: var GodotArray): GodotVariant {.inline.} = + getGDNativeAPI().arrayPopFront(self) + +proc addLast*(self: var GodotArray; value: GodotVariant) {.inline.} = + getGDNativeAPI().arrayPushBack(self, value) + +proc addFirst*(self: var GodotArray; value: GodotVariant) {.inline.} = + getGDNativeAPI().arrayPushFront(self, value) + +proc delete*(self: var GodotArray; idx: cint) {.inline.} = + getGDNativeAPI().arrayRemove(self, idx) + +proc setLen*(self: var GodotArray; size: cint) {.inline.} = + getGDNativeAPI().arrayResize(self, size) -proc delete*(self: var GodotArray; idx: cint) {. - importc: "godot_array_remove".} -proc setLen*(self: var GodotArray; size: cint) {. - importc: "godot_array_resize".} proc rfind*(self: GodotArray; what: GodotVariant; - f: cint): cint {. - noSideEffect, - importc: "godot_array_rfind".} -proc sort*(self: var GodotArray) {.importc: "godot_array_sort".} -proc sortCustom*(self: var GodotArray; obj: var GodotObject; - funcName: GodotString) {. - importc: "godot_array_sort_custom".} + fromIdx: cint): cint {.inline.} = + getGDNativeAPI().arrayRFind(self, what, fromIdx) + +proc sort*(self: var GodotArray) {.inline.} = + getGDNativeAPI().arraySort(self) + +proc sortCustom*(self: var GodotArray; obj: ptr GodotObject; + funcName: GodotString) {.inline.} = + getGDNativeAPI().arraySortCustom(self, obj, funcName) iterator items*(self: GodotArray): GodotVariant = for i in 0.. Date: Thu, 5 Oct 2017 18:55:51 +0700 Subject: [PATCH 085/160] Fix void return type in godotapigen --- godot/godotapigen.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index f718c60..a8c9804 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -532,7 +532,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("GodotString"), ))) - else: + elif meth.returnType != "void": isObjRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")), From f5abff05e6383cbbfdecd144303e05be58941561 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 9 Oct 2017 14:47:28 +0700 Subject: [PATCH 086/160] Extend GDNative API according to the latest update --- godot.nimble | 2 +- godot/gdnativeapi.nim | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index b81ad0e..4ec61f3 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.0" +version = "0.6.1" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index c93e5fa..4a84aeb 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1301,6 +1301,16 @@ type GDNativeAPI* = object stringDestroy*: proc (self: var GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + # StringName API + stringNameNew: pointer + stringNameNewData: pointer + stringNameGetName: pointer + stringNameGetHash: pointer + stringNameGetDataUniquePointer: pointer + stringNameOperatorEqual: pointer + stringNameOperatorLess: pointer + stringNameDestroy: pointer + # Misc API objectDestroy*: proc (self: ptr GodotObject) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} From c5d7680e5368c3fb579b95683fbe189cd024bee5 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 12 Oct 2017 20:55:45 +0700 Subject: [PATCH 087/160] Change GodotClassConstructor to a safe signature --- godot/internal/godotinternaltypes.nim | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim index 5c516f3..29b0e00 100644 --- a/godot/internal/godotinternaltypes.nim +++ b/godot/internal/godotinternaltypes.nim @@ -259,4 +259,5 @@ type numDefaultArgs*: cint defaultArgs*: ptr GodotVariant - GodotClassConstructor* = proc (): ptr GodotObject {.noconv.} + GodotClassConstructor* = proc (): ptr GodotObject {. + noconv, gcsafe, locks: 0, raises: [], tags: [].} From 7f73a89878fee97907d4dcf4852940553dd855ef Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 12 Oct 2017 21:26:36 +0700 Subject: [PATCH 088/160] Fix $ for core types --- godot/core/planes.nim | 3 ++- godot/core/quats.nim | 3 ++- godot/core/rect2.nim | 3 ++- godot/core/rect3.nim | 3 ++- godot/core/transform2d.nim | 3 ++- godot/core/transforms.nim | 3 ++- godot/core/vector2.nim | 3 ++- 7 files changed, 14 insertions(+), 7 deletions(-) diff --git a/godot/core/planes.nim b/godot/core/planes.nim index 360953f..99dd652 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -2,7 +2,8 @@ import vector3 -import internal.godotinternaltypes, godotcoretypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi proc initPlane*(a, b, c, d: float32): Plane {.inline.} = getGDNativeAPI().planeNewWithReals(result, a, b, c, d) diff --git a/godot/core/quats.nim b/godot/core/quats.nim index 016bbd0..ea8cad4 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -1,6 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. -import internal.godotinternaltypes, godotcoretypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi proc initQuat*(x, y, z, w: float32): Quat {.inline.} = result = Quat( diff --git a/godot/core/rect2.nim b/godot/core/rect2.nim index 628e203..ad813a9 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -1,7 +1,8 @@ # Copyright (c) 2017 Xored Software, Inc. import vector2 -import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi proc initRect2*(pos, size: Vector2): Rect2 {.inline.} = Rect2(position: pos, size: size) diff --git a/godot/core/rect3.nim b/godot/core/rect3.nim index 7a2ef72..dc2f2c2 100644 --- a/godot/core/rect3.nim +++ b/godot/core/rect3.nim @@ -1,6 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. -import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi proc initRect3*(pos, size: Vector3): Rect3 {.inline.} = Rect3(position: pos, size: size) diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index 67222c6..922b24b 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -1,6 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. -import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi proc initTransform2D*(): Transform2D {.inline.} = getGDNativeAPI().transform2DNewIdentity(result) diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index 550136c..f70a1f8 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -1,6 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. -import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi import basis proc initTransform*(): Transform {.inline.} = diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 94b5b40..9eca64d 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -1,6 +1,7 @@ # Copyright (c) 2017 Xored Software, Inc. -import internal.godotinternaltypes, godotcoretypes, gdnativeapi +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi proc vec2*(x, y: float32): Vector2 {.inline.} = Vector2(x: x, y: y) From 1b47dac4e96b75e2676e5302be34741c08caed16 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 16 Oct 2017 20:10:00 +0700 Subject: [PATCH 089/160] Fix thread_enter not to use GC --- godot.nimble | 2 +- godot/nim/godotnim.nim | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index 4ec61f3..65e1ff1 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.1" +version = "0.6.2" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index b5c7d78..078e6ab 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -828,7 +828,10 @@ proc godot_nativescript_thread_enter() {.cdecl, exportc, dynlib.} = when compileOption("threads"): setupForeignThreadGc() else: - print(cstring"A foreign thread is created, but app is compiled without --threads:on. Bad things will happen if Nim code is invoked from this thread.") + const err = cstring"A foreign thread is created, but app is compiled without --threads:on. Bad things will happen if Nim code is invoked from this thread." + var s = err.toGodotString() + godotPrint(s) + s.deinit() proc godot_nativescript_thread_exit() {.cdecl, exportc, dynlib.} = when compileOption("threads"): From d2b86a2b9416419db0ae21f46f378972c116d74d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 17 Oct 2017 16:32:07 +0700 Subject: [PATCH 090/160] Perform poll(0) in a loop Temporary workaround for https://github.com/nim-lang/Nim/issues/6523 --- godot/nim/godotnim.nim | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 078e6ab..dbee55f 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -817,7 +817,8 @@ proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = setStackBottom((void*)(&`stackBottom`)); """.} if asyncdispatch.hasPendingOperations(): - poll(0) + for i in 1..10: + poll(0) GC_step(nimGcStepLengthUs, true, 0) when not defined(release): From 26570707aa7c79b260f70ac72dc706dc3c63d054 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 18 Oct 2017 11:47:20 +0700 Subject: [PATCH 091/160] Fix poll loop --- godot/nim/godotnim.nim | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index dbee55f..0b0a765 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -816,8 +816,8 @@ proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = {.emit: """ setStackBottom((void*)(&`stackBottom`)); """.} - if asyncdispatch.hasPendingOperations(): - for i in 1..10: + for _ in 1..10: + if asyncdispatch.hasPendingOperations(): poll(0) GC_step(nimGcStepLengthUs, true, 0) From e494dc914afc047cc0801fc71c4cfcc96886df72 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 8 Nov 2017 11:14:48 +0700 Subject: [PATCH 092/160] Update GDNative API struct --- godot.nimble | 2 +- godot/gdnativeapi.nim | 63 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 65e1ff1..fb8648f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.2" +version = "0.6.3" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 4a84aeb..8af25da 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -295,6 +295,8 @@ type GDNativeAPI* = object {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolByteArrayResize*: proc (self: var GodotPoolByteArray, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayRead: pointer + poolByteArrayWrite: pointer poolByteArraySet*: proc (self: var GodotPoolByteArray, idx: cint, data: byte) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolByteArrayGet*: proc (self: GodotPoolByteArray, idx: cint): byte @@ -330,6 +332,8 @@ type GDNativeAPI* = object {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolIntArrayResize*: proc (self: var GodotPoolIntArray, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayRead: pointer + poolIntArrayWrite: pointer poolIntArraySet*: proc (self: var GodotPoolIntArray, idx: cint, data: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolIntArrayGet*: proc (self: GodotPoolIntArray, idx: cint): cint @@ -367,6 +371,8 @@ type GDNativeAPI* = object {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolRealArrayResize*: proc (self: var GodotPoolRealArray, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayRead: pointer + poolRealArrayWrite: pointer poolRealArraySet*: proc (self: var GodotPoolRealArray, idx: cint, data: float32) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -413,6 +419,8 @@ type GDNativeAPI* = object poolStringArrayResize*: proc (self: var GodotPoolStringArray, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayRead: pointer + poolStringArrayWrite: pointer poolStringArraySet*: proc (self: var GodotPoolStringArray, idx: cint, data: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -459,6 +467,8 @@ type GDNativeAPI* = object poolVector2ArrayResize*: proc (self: var GodotPoolVector2Array, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayRead: pointer + poolVector2ArrayWrite: pointer poolVector2ArraySet*: proc (self: var GodotPoolVector2Array, idx: cint, data: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -504,6 +514,8 @@ type GDNativeAPI* = object poolVector3ArrayResize*: proc (self: var GodotPoolVector3Array, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayRead: pointer + poolVector3ArrayWrite: pointer poolVector3ArraySet*: proc (self: var GodotPoolVector3Array, idx: cint, data: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -545,6 +557,8 @@ type GDNativeAPI* = object {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolColorArrayResize*: proc (self: var GodotPoolColorArray, size: cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayRead: pointer + poolColorArrayWrite: pointer poolColorArraySet*: proc (self: var GodotPoolColorArray, idx: cint, data: Color) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -556,6 +570,52 @@ type GDNativeAPI* = object {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + # Pool Array Read Access API + + poolByteArrayReadAccessPtr: pointer + poolByteArrayReadAccessOperatorAssign: pointer + poolByteArrayReadAccessDestroy: pointer + poolIntArrayReadAccessPtr: pointer + poolIntArrayReadAccessOperatorAssign: pointer + poolIntArrayReadAccessDestroy: pointer + poolRealArrayReadAccessPtr: pointer + poolRealArrayReadAccessOperatorAssign: pointer + poolRealArrayReadAccessDestroy: pointer + poolStringArrayReadAccessPtr: pointer + poolStringArrayReadAccessOperatorAssign: pointer + poolStringArrayReadAccessDestroy: pointer + poolVector2ArrayReadAccessPtr: pointer + poolVector2ArrayReadAccessOperatorAssign: pointer + poolVector2ArrayReadAccessDestroy: pointer + poolVector3ArrayReadAccessPtr: pointer + poolVector3ArrayReadAccessOperatorAssign: pointer + poolVector3ArrayReadAccessDestroy: pointer + poolColorArrayReadAccessPtr: pointer + poolColorArrayReadAccessOperatorAssign: pointer + poolColorArrayReadAccessDestroy: pointer + + poolByteArrayWriteAccessPtr: pointer + poolByteArrayWriteAccessOperatorAssign: pointer + poolByteArrayWriteAccessDestroy: pointer + poolIntArrayWriteAccessPtr: pointer + poolIntArrayWriteAccessOperatorAssign: pointer + poolIntArrayWriteAccessDestroy: pointer + poolRealArrayWriteAccessPtr: pointer + poolRealArrayWriteAccessOperatorAssign: pointer + poolRealArrayWriteAccessDestroy: pointer + poolStringArrayWriteAccessPtr: pointer + poolStringArrayWriteAccessOperatorAssign: pointer + poolStringArrayWriteAccessDestroy: pointer + poolVector2ArrayWriteAccessPtr: pointer + poolVector2ArrayWriteAccessOperatorAssign: pointer + poolVector2ArrayWriteAccessDestroy: pointer + poolVector3ArrayWriteAccessPtr: pointer + poolVector3ArrayWriteAccessOperatorAssign: pointer + poolVector3ArrayWriteAccessDestroy: pointer + poolColorArrayWriteAccessPtr: pointer + poolColorArrayWriteAccessOperatorAssign: pointer + poolColorArrayWriteAccessDestroy: pointer + # Array API arrayNew*: proc (dest: var GodotArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1155,6 +1215,7 @@ type GDNativeAPI* = object stringOperatorIndex: pointer stringCStr*: proc (self: GodotString): cstring {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorIndexConst: pointer stringUTF16Str: pointer stringOperatorEqual*: proc (self, other: GodotString): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1379,6 +1440,8 @@ type GDNativeAPI* = object {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + var gdNativeAPI: ptr GDNativeAPI proc getGDNativeAPI*(): ptr GDNativeAPI {.inline.} = From a93dcd1d4d3f957f04725e89df4d7606323dc4a5 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 8 Nov 2017 11:39:07 +0700 Subject: [PATCH 093/160] Update for latest Nim --- godot.nimble | 2 +- godot/godotapigen.nim | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/godot.nimble b/godot.nimble index fb8648f..0f2f049 100644 --- a/godot.nimble +++ b/godot.nimble @@ -4,4 +4,4 @@ description = "Godot Engine bindings" license = "MIT" srcDir = "godot" -requires "nim >= 0.17.0", "compiler >= 0.17.0" \ No newline at end of file +requires "nim >= 0.17.3", "compiler >= 0.17.3" \ No newline at end of file diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index a8c9804..526a1f8 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -794,7 +794,7 @@ proc genTypeFile(types: Table[string, GodotType], targetDir: string) = ) godotApiTypesTree.add(regNode) - renderModule(godotApiTypesTree, targetDir / "godottypes.nim") + writeFile(targetDir / "godottypes.nim", renderTree(godotApiTypesTree)) proc genSingletonWithDerived(tree: PNode, typ: GodotType, types: Table[string, GodotType]) = @@ -909,7 +909,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) = makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = true) - renderModule(tree, targetDir / moduleName & ".nim") + writeFile(targetDir / moduleName & ".nim", renderTree(tree)) megaImport.add("import \"" & moduleName & "\"\n") From cc6bfa00458a2eee572ee25343a91d4b5a48ef38 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 13 Nov 2017 10:18:25 +0700 Subject: [PATCH 094/160] Update for latest GDNative API changes --- godot.nimble | 2 +- godot/gdnativeapi.nim | 4461 +++++++++++++++++++++++++++------------- godot/nim/godotnim.nim | 5 +- 3 files changed, 3086 insertions(+), 1382 deletions(-) diff --git a/godot.nimble b/godot.nimble index 0f2f049..1349055 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.3" +version = "0.6.4" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 8af25da..ee7f6ad 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1,1451 +1,3154 @@ # Copyright 2017 Xored Software, Inc. -import internal.godotinternaltypes, core.godotcoretypes +import internal.godotinternaltypes, core.godotcoretypes, macros -type GDNativeAPI* = object - next: pointer - version: cstring +type + GDNativeAPIType {.size: sizeof(cuint).} = enum + GDNativeCore, + GDNativeExtNativeScript, + GDNativeExtPluginScript, + GDNativeExtNativeARVR - # Color API - colorNewRGBA*: proc (dest: var Color, r, g, b, a: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorNewRGB*: proc (dest: var Color, r, g, b: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetR*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorSetR*: proc (self: var Color, r: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetG*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorSetG*: proc (self: var Color, g: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetB*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorSetB*: proc (self: var Color, b: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetA*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorSetA*: proc (self: var Color, a: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetH*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetS*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGetV*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorAsString*: proc (self: Color): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorToRGBA32*: proc (self: Color): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorAsARGB32*: proc (self: Color): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorGray*: proc (self: Color): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorInverted*: proc (self: Color): Color - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorContrasted*: proc (self: Color): Color - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorLinearInterpolate*: proc (self, other: Color, t: float32): Color - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - colorBlend*: proc (self, other: Color): Color - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorToHtml*: proc (self: Color, withAlpha: bool): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorOperatorEqual*: proc (self, other: Color): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorOperatorLess*: proc (self, other: Color): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + GDNativeAPIVersion = object + major: cuint + minor: cuint - # Vector2 API - vector2New*: proc (dest: var Vector2, x, y: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2AsString*: proc (self: Vector2): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Normalized*: proc (self: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Length*: proc (self: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Angle*: proc (self: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2LengthSquared*: proc (self: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2IsNormalized*: proc (self: Vector2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2DistanceTo*: proc (self, to: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2DistanceSquaredTo*: proc (self, to: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - vector2AngleTo*: proc (self, to: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2AngleToPoint*: proc (self, to: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2LinearInterpolate*: proc (self, b: Vector2, t: float32): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - vector2CubicInterpolate*: proc (self, b, preA, postB: Vector2, - t: float32): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - vector2Rotated*: proc (self: Vector2, phi: float32): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Tangent*: proc (self: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Floor*: proc (self: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Snapped*: proc (self, by: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Aspect*: proc (self: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Dot*: proc (self, other: Vector2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Slide*: proc (self, n: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Bounce*: proc (self, n: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Reflect*: proc (self, n: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Abs*: proc (self: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Clamped*: proc (self: Vector2, length: float32): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorAdd*: proc (self, other: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorSubtract*: proc (self, other: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - vector2OperatorMultiplyVector*: proc (self, other: Vector2): Vector2 + GDNativeAPIHeader = object + typ: cuint + version: GDNativeAPIVersion + next: pointer + + GDNativeNativeScriptAPI1 = object + typ: cuint + version: GDNativeAPIVersion + next: pointer + nativeScriptRegisterClass: proc (gdnativeHandle: pointer, + name, base: cstring, + createFunc: GodotInstanceCreateFunc, + destroyFunc: GodotInstanceDestroyFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterToolClass: proc (gdnativeHandle: pointer, + name, base: cstring, + createFunc: GodotInstanceCreateFunc, + destroyFunc: GodotInstanceDestroyFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterMethod: proc (gdnativeHandle: pointer, + name, functionName: cstring, + attr: GodotMethodAttributes, + meth: GodotInstanceMethod) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterProperty: proc (gdnativeHandle: pointer, + name, path: cstring, + attr: ptr GodotPropertyAttributes, + setFunc: GodotPropertySetFunc, + getFunc: GodotPropertyGetFunc) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorMultiplyScalar*: proc (self: Vector2, scalar: float32): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - vector2OperatorDivideVector*: proc (self, other: Vector2): Vector2 + nativeScriptRegisterSignal: proc (gdnativeHandle: pointer, name: cstring, + signal: GodotSignal) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorDivideScalar*: proc (self: Vector2, scalar: float32): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - vector2OperatorEqual*: proc (self, other: Vector2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorLess*: proc (self, other: Vector2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorNeg*: proc (self: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2SetX: pointer - vector2SetY: pointer - vector2GetX: pointer - vector2GetY: pointer + nativeScriptGetUserdata: proc (obj: ptr GodotObject): pointer + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} - # Quat API - quatNew*: proc (dest: var Quat, x, y, z, w: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatNewWithAxisAngle*: proc (dest: Quat, axis: Vector3, - angle: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatGetX*: proc (self: Quat): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSetX*: proc (self: var Quat, val: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatGetY*: proc (self: Quat): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSetY*: proc (self: var Quat, val: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatGetZ*: proc (self: Quat): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSetZ*: proc (self: var Quat, val: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatGetW*: proc (self: Quat): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSetW*: proc (self: var Quat, val: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatAsString*: proc (self: Quat): GodotString + GDNativeCoreAPI1 = object + typ: cuint + version: GDNativeAPIVersion + next: pointer + numExtensions: cuint + extensions: ptr array[100_000, pointer] + + # Color API + colorNewRGBA: proc (dest: var Color, r, g, b, a: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorNewRGB: proc (dest: var Color, r, g, b: float32) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatLength*: proc (self: Quat): float32 + colorGetR: proc (self: Color): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatLengthSquared*: proc (self: Quat): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatNormalized*: proc (self: Quat): Quat + colorSetR: proc (self: var Color, r: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetG: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetG: proc (self: var Color, g: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetB: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetB: proc (self: var Color, b: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetA: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetA: proc (self: var Color, a: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetH: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetS: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetV: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorAsString: proc (self: Color): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatIsNormalized*: proc (self: Quat): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatInverse*: proc (self: Quat): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatDot*: proc (self, other: Quat): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatXform*: proc (self: Quat, v: Vector3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSlerp*: proc (self, other: Quat, t: float32): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSlerpni*: proc (self, other: Quat, t: float32): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatCubicSlerp*: proc (self, other, preA, postB: Quat, t: float32): Quat + colorToRGBA32: proc (self: Color): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorMultiply*: proc (self: Quat, b: float32): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorAdd*: proc (self, other: Quat): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorSubtract*: proc (self, other: Quat): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorDivide*: proc (self: Quat, divider: float32): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorEqual*: proc (self, other: Quat): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorNeg*: proc (self: Quat): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # Basis API - basisNewWithRows: pointer - basisNewWithAxisAndAngle: pointer - basisNewWithEuler: pointer - basisAsString: pointer - basisInverse: pointer - basisTransposed: pointer - basisOrthonormalized: pointer - basisDeterminant: pointer - basisRotated: pointer - basisScaled: pointer - basisGetScale: pointer - basisGetEuler: pointer - basisTdotx: pointer - basisTdoty: pointer - basisTdotz: pointer - basisXform: pointer - basisXformInv: pointer - basisGetOrthogonalIndex: pointer - basisNew: pointer - basisNewWithEulerQuat: pointer - basisGetElements: pointer - basisGetAxis: pointer - basisSetAxis: pointer - basisGetRow: pointer - basisSetRow: pointer - basisOperatorEqual: pointer - basisOperatorAdd: pointer - basisOperatorSubstract: pointer - basisOperatorMultiplyVector: pointer - basisOperatorMultiplyScalar: pointer - - # Vector3 API - vector3New: pointer - vector3AsString: pointer - vector3MinAxis: pointer - vector3MaxAxis: pointer - vector3Length: pointer - vector3Length_squared: pointer - vector3IsNormalized: pointer - vector3Normalized: pointer - vector3Inverse: pointer - vector3Snapped: pointer - vector3Rotated: pointer - vector3LinearInterpolate: pointer - vector3CubicInterpolate: pointer - vector3Dot: pointer - vector3Cross: pointer - vector3Outer: pointer - vector3ToDiagonalMatrix: pointer - vector3Abs: pointer - vector3Floor: pointer - vector3Ceil: pointer - vector3DistanceTo: pointer - vector3DistanceSquaredTo: pointer - vector3AngleTo: pointer - vector3Slide: pointer - vector3Bounce: pointer - vector3Reflect: pointer - vector3OperatorAdd: pointer - vector3OperatorSubstract: pointer - vector3OperatorMultiplyVector: pointer - vector3OperatorMultiplyScalar: pointer - vector3OperatorDivideVector: pointer - vector3OperatorDivideScalar: pointer - vector3OperatorEqual: pointer - vector3OperatorLess: pointer - vector3OperatorNeg: pointer - vector3SetAxis: pointer - vector3GetAxis: pointer - - # PoolByteArray API - poolByteArrayNew*: proc (dest: var GodotPoolByteArray) + colorAsARGB32: proc (self: Color): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGray: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorInverted: proc (self: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorContrasted: proc (self: Color): Color {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayNewCopy*: proc (dest: var GodotPoolByteArray, - src: GodotPoolByteArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayNewWithArray*: proc (dest: var GodotPoolByteArray, - src: GodotArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolByteArrayAppend*: proc (self: var GodotPoolByteArray, - val: byte) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayAppendArray*: proc (self: var GodotPoolByteArray, - arr: GodotPoolByteArray) + colorLinearInterpolate: proc (self, other: Color, t: float32): Color {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayInsert*: proc (self: var GodotPoolByteArray, - idx: cint, val: byte): Error - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayInvert*: proc (self: var GodotPoolByteArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayPushBack*: proc (self: var GodotPoolByteArray, val: byte) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolByteArrayRemove*: proc (self: var GodotPoolByteArray, idx: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayResize*: proc (self: var GodotPoolByteArray, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayRead: pointer - poolByteArrayWrite: pointer - poolByteArraySet*: proc (self: var GodotPoolByteArray, idx: cint, data: byte) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayGet*: proc (self: GodotPoolByteArray, idx: cint): byte - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArraySize*: proc (self: GodotPoolByteArray): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolByteArrayDestroy*: proc (self: GodotPoolByteArray) + colorBlend: proc (self, other: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorToHtml: proc (self: Color, withAlpha: bool): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorOperatorEqual: proc (self, other: Color): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorOperatorLess: proc (self, other: Color): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - # PoolIntArray API - poolIntArrayNew*: proc (dest: var GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayNewCopy*: proc (dest: var GodotPoolIntArray, - src: GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayNewWithArray*: proc (dest: var GodotPoolIntArray, src: GodotArray) + # Vector2 API + vector2New: proc (dest: var Vector2, x, y: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2AsString: proc (self: Vector2): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Normalized: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Length: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Angle: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2LengthSquared: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2IsNormalized: proc (self: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2DistanceTo: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2DistanceSquaredTo: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2AngleTo: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2AngleToPoint: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2LinearInterpolate: proc (self, b: Vector2, t: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2CubicInterpolate: proc (self, b, preA, postB: Vector2, + t: float32): Vector2 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayAppend*: proc (self: var GodotPoolIntArray, val: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayAppendArray*: proc (self: var GodotPoolIntArray, - arr: GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolIntArrayInsert*: proc (self: var GodotPoolIntArray, idx: cint, - val: cint): Error - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayInvert*: proc (self: var GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayPushBack*: proc (self: var GodotPoolIntArray, val: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayRemove*: proc (self: var GodotPoolIntArray, idx: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayResize*: proc (self: var GodotPoolIntArray, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayRead: pointer - poolIntArrayWrite: pointer - poolIntArraySet*: proc (self: var GodotPoolIntArray, idx: cint, data: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayGet*: proc (self: GodotPoolIntArray, idx: cint): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArraySize*: proc (self: GodotPoolIntArray): cint + vector2Rotated: proc (self: Vector2, phi: float32): Vector2 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolIntArrayDestroy*: proc (self: GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # PoolRealArray API - poolRealArrayNew*: proc (dest: var GodotPoolRealArray) + vector2Tangent: proc (self: Vector2): Vector2 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayNewCopy*: proc (dest: var GodotPoolRealArray, - src: GodotPoolRealArray) + vector2Floor: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Snapped: proc (self, by: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Aspect: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Dot: proc (self, other: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Slide: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Bounce: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Reflect: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Abs: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Clamped: proc (self: Vector2, length: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorAdd: proc (self, other: Vector2): Vector2 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayNewWithArray*: proc (dest: var GodotPoolRealArray, - src: GodotArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolRealArrayAppend*: proc (self: var GodotPoolRealArray, val: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayAppendArray*: proc (self: var GodotPoolRealArray, - arr: GodotPoolRealArray) + vector2OperatorSubtract: proc (self, other: Vector2): Vector2 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayInsert*: proc (self: var GodotPoolRealArray, - idx: cint, val: float32): Error - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayInvert*: proc (self: var GodotPoolRealArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayPushBack*: proc (self: var GodotPoolRealArray, val: float32) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolRealArrayRemove*: proc (self: var GodotPoolRealArray, idx: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayResize*: proc (self: var GodotPoolRealArray, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayRead: pointer - poolRealArrayWrite: pointer - poolRealArraySet*: proc (self: var GodotPoolRealArray, idx: cint, - data: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayGet*: proc (self: GodotPoolRealArray, idx: cint): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArraySize*: proc (self: GodotPoolRealArray): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayDestroy*: proc (self: GodotPoolRealArray) + vector2OperatorMultiplyVector: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyScalar: proc (self: Vector2, scalar: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideVector: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideScalar: proc (self: Vector2, scalar: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorEqual: proc (self, other: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorLess: proc (self, other: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorNeg: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2SetX: pointer + vector2SetY: pointer + vector2GetX: pointer + vector2GetY: pointer - # PoolStringArray API - poolStringArrayNew*: proc (dest: var GodotPoolStringArray) + # Quat API + quatNew: proc (dest: var Quat, x, y, z, w: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatNewWithAxisAngle: proc (dest: Quat, axis: Vector3, + angle: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetX: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetX: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetY: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetY: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetZ: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetZ: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetW: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetW: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatAsString: proc (self: Quat): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatLength: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatLengthSquared: proc (self: Quat): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayNewCopy*: proc (dest: var GodotPoolStringArray, - src: GodotPoolStringArray) + quatNormalized: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatIsNormalized: proc (self: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatInverse: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatDot: proc (self, other: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatXform: proc (self: Quat, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerp: proc (self, other: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerpni: proc (self, other: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatCubicSlerp: proc (self, other, preA, postB: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorMultiply: proc (self: Quat, b: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorAdd: proc (self, other: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorSubtract: proc (self, other: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorDivide: proc (self: Quat, divider: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorEqual: proc (self, other: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorNeg: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Basis API + basisNewWithRows: pointer + basisNewWithAxisAndAngle: pointer + basisNewWithEuler: pointer + basisAsString: pointer + basisInverse: pointer + basisTransposed: pointer + basisOrthonormalized: pointer + basisDeterminant: pointer + basisRotated: pointer + basisScaled: pointer + basisGetScale: pointer + basisGetEuler: pointer + basisTdotx: pointer + basisTdoty: pointer + basisTdotz: pointer + basisXform: pointer + basisXformInv: pointer + basisGetOrthogonalIndex: pointer + basisNew: pointer + basisNewWithEulerQuat: pointer + basisGetElements: pointer + basisGetAxis: pointer + basisSetAxis: pointer + basisGetRow: pointer + basisSetRow: pointer + basisOperatorEqual: pointer + basisOperatorAdd: pointer + basisOperatorSubstract: pointer + basisOperatorMultiplyVector: pointer + basisOperatorMultiplyScalar: pointer + + # Vector3 API + vector3New: pointer + vector3AsString: pointer + vector3MinAxis: pointer + vector3MaxAxis: pointer + vector3Length: pointer + vector3Length_squared: pointer + vector3IsNormalized: pointer + vector3Normalized: pointer + vector3Inverse: pointer + vector3Snapped: pointer + vector3Rotated: pointer + vector3LinearInterpolate: pointer + vector3CubicInterpolate: pointer + vector3Dot: pointer + vector3Cross: pointer + vector3Outer: pointer + vector3ToDiagonalMatrix: pointer + vector3Abs: pointer + vector3Floor: pointer + vector3Ceil: pointer + vector3DistanceTo: pointer + vector3DistanceSquaredTo: pointer + vector3AngleTo: pointer + vector3Slide: pointer + vector3Bounce: pointer + vector3Reflect: pointer + vector3OperatorAdd: pointer + vector3OperatorSubstract: pointer + vector3OperatorMultiplyVector: pointer + vector3OperatorMultiplyScalar: pointer + vector3OperatorDivideVector: pointer + vector3OperatorDivideScalar: pointer + vector3OperatorEqual: pointer + vector3OperatorLess: pointer + vector3OperatorNeg: pointer + vector3SetAxis: pointer + vector3GetAxis: pointer + + # PoolByteArray API + poolByteArrayNew: proc (dest: var GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayNewCopy: proc (dest: var GodotPoolByteArray, + src: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayNewWithArray: proc (dest: var GodotPoolByteArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolByteArrayAppend: proc (self: var GodotPoolByteArray, + val: byte) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayAppendArray: proc (self: var GodotPoolByteArray, + arr: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolByteArrayInsert: proc (self: var GodotPoolByteArray, + idx: cint, val: byte): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayInvert: proc (self: var GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayPushBack: proc (self: var GodotPoolByteArray, val: byte) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayNewWithArray*: proc (dest: var GodotPoolStringArray, + poolByteArrayRemove: proc (self: var GodotPoolByteArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayResize: proc (self: var GodotPoolByteArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayRead: pointer + poolByteArrayWrite: pointer + poolByteArraySet: proc (self: var GodotPoolByteArray, idx: cint, data: byte) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayGet: proc (self: GodotPoolByteArray, idx: cint): byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArraySize: proc (self: GodotPoolByteArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayDestroy: proc (self: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolIntArray API + poolIntArrayNew: proc (dest: var GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayNewCopy: proc (dest: var GodotPoolIntArray, + src: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayNewWithArray: proc (dest: var GodotPoolIntArray, src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolIntArrayAppend: proc (self: var GodotPoolIntArray, val: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayAppendArray: proc (self: var GodotPoolIntArray, + arr: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolIntArrayInsert: proc (self: var GodotPoolIntArray, idx: cint, + val: cint): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayInvert: proc (self: var GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayPushBack: proc (self: var GodotPoolIntArray, val: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayRemove: proc (self: var GodotPoolIntArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayResize: proc (self: var GodotPoolIntArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayRead: pointer + poolIntArrayWrite: pointer + poolIntArraySet: proc (self: var GodotPoolIntArray, idx: cint, data: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayGet: proc (self: GodotPoolIntArray, idx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArraySize: proc (self: GodotPoolIntArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayDestroy: proc (self: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolRealArray API + poolRealArrayNew: proc (dest: var GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayNewCopy: proc (dest: var GodotPoolRealArray, + src: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayNewWithArray: proc (dest: var GodotPoolRealArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayAppend: proc (self: var GodotPoolRealArray, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayAppendArray: proc (self: var GodotPoolRealArray, + arr: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayInsert: proc (self: var GodotPoolRealArray, + idx: cint, val: float32): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayInvert: proc (self: var GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayPushBack: proc (self: var GodotPoolRealArray, val: float32) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayRemove: proc (self: var GodotPoolRealArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayResize: proc (self: var GodotPoolRealArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayRead: pointer + poolRealArrayWrite: pointer + poolRealArraySet: proc (self: var GodotPoolRealArray, idx: cint, + data: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayGet: proc (self: GodotPoolRealArray, idx: cint): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArraySize: proc (self: GodotPoolRealArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayDestroy: proc (self: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolStringArray API + poolStringArrayNew: proc (dest: var GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayNewCopy: proc (dest: var GodotPoolStringArray, + src: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayNewWithArray: proc (dest: var GodotPoolStringArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayAppend: proc (self: var GodotPoolStringArray, + val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayAppendArray: proc (self: var GodotPoolStringArray, + arr: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayInsert: proc (self: var GodotPoolStringArray, + idx: cint, val: GodotString): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayInvert: proc (self: var GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayPushBack: proc (self: var GodotPoolStringArray, + val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayRemove: proc (self: var GodotPoolStringArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayResize: proc (self: var GodotPoolStringArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayRead: pointer + poolStringArrayWrite: pointer + poolStringArraySet: proc (self: var GodotPoolStringArray, idx: cint, + data: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayGet: proc (self: GodotPoolStringArray, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArraySize: proc (self: GodotPoolStringArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayDestroy: proc (self: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolVector2 API + poolVector2ArrayNew: proc (dest: var GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayNewCopy: proc (dest: var GodotPoolVector2Array, + src: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayNewWithArray: proc (dest: var GodotPoolVector2Array, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayAppend: proc (self: var GodotPoolVector2Array, val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayAppendArray: proc (self: var GodotPoolVector2Array, + arr: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayInsert: proc (self: var GodotPoolVector2Array, idx: cint, + val: Vector2): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayInvert: proc (self: var GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayPushBack: proc (self: var GodotPoolVector2Array, + val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayRemove: proc (self: var GodotPoolVector2Array, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayResize: proc (self: var GodotPoolVector2Array, size: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayRead: pointer + poolVector2ArrayWrite: pointer + poolVector2ArraySet: proc (self: var GodotPoolVector2Array, idx: cint, + data: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayGet: proc (self: GodotPoolVector2Array, idx: cint): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArraySize: proc (self: GodotPoolVector2Array): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayDestroy: proc (self: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolVector3 API + poolVector3ArrayNew: proc (dest: var GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayNewCopy: proc (dest: var GodotPoolVector3Array, + src: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayNewWithArray: proc (dest: var GodotPoolVector3Array, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayAppend: proc (self: var GodotPoolVector3Array, val: Vector3) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayAppendArray: proc (self: var GodotPoolVector3Array, + arr: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayInsert: proc (self: var GodotPoolVector3Array, idx: cint, + val: Vector3): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayInvert: proc (self: var GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayPushBack: proc (self: var GodotPoolVector3Array, + val: Vector3) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayRemove: proc (self: var GodotPoolVector3Array, + idx: cint) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayResize: proc (self: var GodotPoolVector3Array, + size: cint) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayRead: pointer + poolVector3ArrayWrite: pointer + poolVector3ArraySet: proc (self: var GodotPoolVector3Array, idx: cint, + data: Vector3) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayGet: proc (self: GodotPoolVector3Array, idx: cint): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArraySize: proc (self: GodotPoolVector3Array): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayDestroy: proc (self: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolColorArray API + poolColorArrayNew: proc (dest: var GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayNewCopy: proc (dest: var GodotPoolColorArray, + src: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayNewWithArray: proc (dest: var GodotPoolColorArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayAppend: proc (self: var GodotPoolColorArray, + val: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayAppendArray: proc (self: var GodotPoolColorArray, + arr: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayInsert: proc (self: var GodotPoolColorArray, + idx: cint, val: Color): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayInvert: proc (self: var GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayPushBack: proc (self: var GodotPoolColorArray, val: Color) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayRemove: proc (self: var GodotPoolColorArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayResize: proc (self: var GodotPoolColorArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayRead: pointer + poolColorArrayWrite: pointer + poolColorArraySet: proc (self: var GodotPoolColorArray, idx: cint, + data: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayGet: proc (self: GodotPoolColorArray, idx: cint): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArraySize: proc (self: GodotPoolColorArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayDestroy: proc (self: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Pool Array Read Access API + + poolByteArrayReadAccessPtr: pointer + poolByteArrayReadAccessOperatorAssign: pointer + poolByteArrayReadAccessDestroy: pointer + poolIntArrayReadAccessPtr: pointer + poolIntArrayReadAccessOperatorAssign: pointer + poolIntArrayReadAccessDestroy: pointer + poolRealArrayReadAccessPtr: pointer + poolRealArrayReadAccessOperatorAssign: pointer + poolRealArrayReadAccessDestroy: pointer + poolStringArrayReadAccessPtr: pointer + poolStringArrayReadAccessOperatorAssign: pointer + poolStringArrayReadAccessDestroy: pointer + poolVector2ArrayReadAccessPtr: pointer + poolVector2ArrayReadAccessOperatorAssign: pointer + poolVector2ArrayReadAccessDestroy: pointer + poolVector3ArrayReadAccessPtr: pointer + poolVector3ArrayReadAccessOperatorAssign: pointer + poolVector3ArrayReadAccessDestroy: pointer + poolColorArrayReadAccessPtr: pointer + poolColorArrayReadAccessOperatorAssign: pointer + poolColorArrayReadAccessDestroy: pointer + + poolByteArrayWriteAccessPtr: pointer + poolByteArrayWriteAccessOperatorAssign: pointer + poolByteArrayWriteAccessDestroy: pointer + poolIntArrayWriteAccessPtr: pointer + poolIntArrayWriteAccessOperatorAssign: pointer + poolIntArrayWriteAccessDestroy: pointer + poolRealArrayWriteAccessPtr: pointer + poolRealArrayWriteAccessOperatorAssign: pointer + poolRealArrayWriteAccessDestroy: pointer + poolStringArrayWriteAccessPtr: pointer + poolStringArrayWriteAccessOperatorAssign: pointer + poolStringArrayWriteAccessDestroy: pointer + poolVector2ArrayWriteAccessPtr: pointer + poolVector2ArrayWriteAccessOperatorAssign: pointer + poolVector2ArrayWriteAccessDestroy: pointer + poolVector3ArrayWriteAccessPtr: pointer + poolVector3ArrayWriteAccessOperatorAssign: pointer + poolVector3ArrayWriteAccessDestroy: pointer + poolColorArrayWriteAccessPtr: pointer + poolColorArrayWriteAccessOperatorAssign: pointer + poolColorArrayWriteAccessDestroy: pointer + + # Array API + arrayNew: proc (dest: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewCopy: proc (dest: var GodotArray, src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewPoolColorArray: proc (dest: var GodotArray, src: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolVector3Array: proc (dest: var GodotArray, + src: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolVector2Array: proc (dest: var GodotArray, + src: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolStringArray: proc (dest: var GodotArray, + src: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolRealArray: proc (dest: var GodotArray, src: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolIntArray: proc (dest: var GodotArray, src: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewPoolByteArray: proc (dest: var GodotArray, src: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arraySet: proc (self: var GodotArray, idx: cint, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayGet: proc (self: GodotArray, idx: cint): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayOperatorIndex: proc (self: var GodotArray, idx: cint): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayOperatorIndexConst: pointer + arrayAppend: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayClear: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayCount: proc (self: GodotArray, val: GodotVariant): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayEmpty: proc (self: GodotArray): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayErase: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFront: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBack: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFind: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFindLast: proc (self: GodotArray, what: GodotVariant): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayHas: proc (self: GodotArray, val: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayHash: proc (self: GodotArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayInsert: proc (self: var GodotArray, pos: cint, val: GodotVariant): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayInvert: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPopBack: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPopFront: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPushBack: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPushFront: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayRemove: proc (self: var GodotArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayResize: proc (self: var GodotArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayRFind: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySize: proc (self: GodotArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySort: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySortCustom: proc (self: var GodotArray, obj: ptr GodotObject, + f: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayDestroy: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Dictionary API + dictionaryNew: proc (dest: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryNewCopy: proc (dest: var GodotDictionary, src: GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryDestroy: proc (self: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionarySize: proc (self: GodotDictionary): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryEmpty: proc (self: GodotDictionary): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryClear: proc (self: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHas: proc (self: GodotDictionary, key: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHasAll: proc (self: GodotDictionary, keys: GodotArray): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryErase: proc (self: var GodotDictionary, key: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHash: proc (self: GodotDictionary): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryKeys: proc (self: GodotDictionary): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryValues: proc (self: GodotDictionary): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryGet: proc (self: GodotDictionary, key: GodotVariant): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionarySet: proc (self: var GodotDictionary, key, value: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryOperatorIndex: proc (self: var GodotDictionary, + key: GodotVariant): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + dictionaryOperatorIndexConst: pointer + dictionaryNext: proc (self: GodotDictionary, + key: GodotVariant): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryOperatorEqual: proc (self, other: GodotDictionary): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + dictionaryToJson: proc (self: GodotDictionary): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # NodePath API + nodePathNew: proc (dest: var GodotNodePath, src: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathNewCopy: proc (dest: var GodotNodePath, src: GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathDestroy: proc (self: var GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathAsString: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathIsAbsolute: proc (self: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetNameCount: proc (self: GodotNodePath): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetName: proc (self: GodotNodePath, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetSubnameCount: proc (self: GodotNodePath): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nodePathGetSubname: proc (self: GodotNodePath, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetProperty: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathIsEmpty: proc (self: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathOperatorEqual: proc (self, other: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Plane API + planeNewWithReals: proc (dest: var Plane, a, b, c, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNewWithVectors: proc (dest: var Plane, v1, v2, v3: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNewWithNormal: proc (dest: var Plane, normal: Vector3, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeAsString: proc (self: Plane): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNormalized: proc (self: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeCenter: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetAnyPoint: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIsPointOver: proc (self: Plane, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeDistanceTo: proc (self: Plane, point: Vector3): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeHasPoint: proc (self: Plane, point: Vector3, epsilon: float32): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeProject: proc (self: Plane, point: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersect3: proc (self: Plane, dest: var Vector3, b, c: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersectsRay: proc (self: Plane, dest: var Vector3, + point, dir: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersectsSegment: proc (self: Plane, dest: var Vector3, + segmentBegin, segmentEnd: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + planeOperatorNeg: proc (self: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeOperatorEqual: proc (self, other: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeSetNormal: proc (self: var Plane, normal: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetNormal: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetD: proc (self: Plane): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeSetD: proc (self: var Plane, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Rect2 API + rect2NewWithPositionAndSize: proc (dest: var Rect2, pos, size: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect2New: proc (dest: var Rect2, x, y, width, height: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2AsString: proc (self: Rect2): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetArea: proc (self: Rect2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Intersects: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Encloses: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2HasNoArea: proc (self: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Clip: proc (self, other: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Merge: proc (self, other: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2HasPoint: proc (self: Rect2, point: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Grow: proc (self: Rect2, by: float32): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Expand: proc (self: Rect2, to: Vector2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2OperatorEqual: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetPosition: proc (self: Rect2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetSize: proc (self: Rect2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2SetPosition: proc (self: var Rect2, pos: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2SetSize: proc (self: var Rect2, size: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Rect3 API + rect3New: proc (dest: var Rect3, pos, size: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetPosition: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3SetPosition: proc (self: var Rect3, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetSize: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3SetSize: proc (self: var Rect3, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3AsString: proc (self: Rect3): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetArea: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3HasNoArea: proc (self: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3HasNoSurface: proc (self: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Intersects: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Encloses: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Merge: proc (self, other: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Intersection: proc (self, other: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3IntersectsPlane: proc (self: Rect3, plane: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3IntersectsSegment: proc (self: Rect3, vFrom, vTo: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3HasPoint: proc (self: Rect3, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetSupport: proc (self: Rect3, dir: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetLongestAxis: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetLongestAxisIndex: proc (self: Rect3): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetLongestAxisSize: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetShortestAxis: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetShortestAxisIndex: proc (self: Rect3): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetShortestAxisSize: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3Expand: proc (self: Rect3, toPoint: Vector3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Grow: proc (self: Rect3, by: float32): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetEndpoint: proc (self: Rect3, idx: cint): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3OperatorEqual: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # RID API + ridNew: proc (dest: var RID) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridGetID: proc (self: RID): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridNewWithResource: proc (dest: var RID, obj: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridOperatorEqual: proc (self, other: RID): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridOperatorLess: proc (self, other: RID): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Transform API + transformNewWithAxisOrigin: proc (dest: var Transform, + xAxis, yAxis, zAxis, origin: Vector3) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformNew: proc (dest: var Transform, basis: Basis, origin: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformGetBasis: proc (self: Transform): Basis + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetBasis: proc (self: var Transform, basis: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformGetOrigin: proc (self: Transform): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetOrigin: proc (self: var Transform, v: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAsString: proc (self: Transform): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformInverse: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAffineInverse: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOrthonormalized: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformRotated: proc (self: Transform, axis: Vector3, + phi: float32): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformScaled: proc (self: Transform, scale: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformTranslated: proc (self: Transform, offset: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformLookingAt: proc (self: Transform, target, up: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformPlane: proc (self: Transform, plane: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvPlane: proc (self: Transform, plane: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformNewIdentity: proc (dest: var Transform) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformOperatorEqual: proc (self, other: Transform): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOperatorMultiply: proc (self, other: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformVector3: proc (self: Transform, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformInvVector3: proc (self: Transform, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformRect3: proc (self: Transform, v: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvRect3: proc (self: Transform, v: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Transform2D API + transform2DNew: proc (dest: var Transform2D, rot: float32, pos: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DNewAxisOrigin: proc (dest: var Transform2D, + xAxis, yAxis, origin: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DAsString: proc (self: Transform2D): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DInverse: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DAffineInverse: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DGetRotation: proc (self: Transform2D): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DGetOrigin: proc (self: Transform2D): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DGetScale: proc (self: Transform2D): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DOrthonormalized: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DRotated: proc (self: Transform2D, phi: float32): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DScaled: proc (self: Transform2D, scale: Vector2): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DTranslated: proc (self: Transform2D, offset: Vector2): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformVector2: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvVector2: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformVector2: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformInvVector2: proc (self: Transform2D, + v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DInterpolateWith: proc (self, other: Transform2D, + t: float32): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DOperatorEqual: proc (self, other: Transform2D): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DOperatorMultiply: proc (self, other: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DNewIdentity: proc (dest: var Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformRect2: proc (self: Transform2D, v: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvRect2: proc (self: Transform2D, v: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Variant API + variantGetType: proc (v: GodotVariant): VariantType + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewCopy: proc (dest: var GodotVariant, src: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewNil: proc (dest: var GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewBool: proc (dest: var GodotVariant, val: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewUInt: proc (dest: var GodotVariant, val: uint64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewInt: proc (dest: var GodotVariant, val: int64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewReal: proc (dest: var GodotVariant, val: float64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewString: proc (dest: var GodotVariant, val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewVector2: proc (dest: var GodotVariant, val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRect2: proc (dest: var GodotVariant, val: Rect2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewVector3: proc (dest: var GodotVariant, val: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewTransform2D: proc (dest: var GodotVariant, val: Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPlane: proc (dest: var GodotVariant, val: Plane) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewQuat: proc (dest: var GodotVariant, val: Quat) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRect3: proc (dest: var GodotVariant, val: Rect3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewBasis: proc (dest: var GodotVariant, val: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewTransform: proc (dest: var GodotVariant, val: Transform) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewColor: proc (dest: var GodotVariant, val: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewNodePath: proc (dest: var GodotVariant, val: GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRID: proc (dest: var GodotVariant, val: RID) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewObject: proc (dest: var GodotVariant, val: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewDictionary: proc (dest: var GodotVariant, val: GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewArray: proc (dest: var GodotVariant, val: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewPoolByteArray: proc (dest: var GodotVariant, + val: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolIntArray: proc (dest: var GodotVariant, val: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolRealArray: proc (dest: var GodotVariant, + val: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolStringArray: proc (dest: var GodotVariant, + val: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolVector2Array: proc (dest: var GodotVariant, + val: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolVector3Array: proc (dest: var GodotVariant, + val: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolColorArray: proc (dest: var GodotVariant, + val: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsBool: proc (self: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsUInt: proc (self: GodotVariant): uint64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsInt: proc (self: GodotVariant): int64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsReal: proc (self: GodotVariant): float64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsString: proc (self: GodotVariant): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector2: proc (self: GodotVariant): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect2: proc (self: GodotVariant): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector3: proc (self: GodotVariant): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform2D: proc (self: GodotVariant): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPlane: proc (self: GodotVariant): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsQuat: proc (self: GodotVariant): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect3: proc (self: GodotVariant): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsBasis: proc (self: GodotVariant): Basis + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform: proc (self: GodotVariant): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsColor: proc (self: GodotVariant): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsNodePath: proc (self: GodotVariant): GodotNodePath + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRID: proc (self: GodotVariant): RID + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsObject: proc (self: GodotVariant): ptr GodotObject + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsDictionary: proc (self: GodotVariant): GodotDictionary + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsArray: proc (self: GodotVariant): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPoolByteArray: proc (self: GodotVariant): GodotPoolByteArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolIntArray: proc (self: GodotVariant): GodotPoolIntArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolRealArray: proc (self: GodotVariant): GodotPoolRealArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolStringArray: proc (self: GodotVariant): GodotPoolStringArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolVector2Array: proc (self: GodotVariant): GodotPoolVector2Array + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolVector3Array: proc (self: GodotVariant): GodotPoolVector3Array + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolColorArray: proc (self: GodotVariant): GodotPoolColorArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantCall: proc (self: var GodotVariant, meth: GodotString, + args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], + argcount: cint, + callError: var VariantCallError): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantHasMethod: proc (self: GodotVariant, meth: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantOperatorEqual: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantOperatorLess: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantHashCompare: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantBooleanize: proc (self: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantDestroy: proc (self: var GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # String API + stringNew: proc (dest: var GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewCopy: proc (dest: var GodotString, src: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewData: proc (dest: var GodotString, contents: cstring, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewUTF16Data: pointer + stringGetData: proc (self: GodotString, dest: cstring, size: var cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorIndex: pointer + stringCStr: proc (self: GodotString): cstring + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorIndexConst: pointer + stringUTF16Str: pointer + stringOperatorEqual: proc (self, other: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorLess: proc (self, other: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorPlus: proc (self, other: GodotString): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringLength: proc (self: GodotString): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringBeginsWith: pointer + stringBeginsWithCharArray: pointer + stringBigrams: pointer + stringChr: pointer + stringEndsWith: pointer + stringFind: pointer + stringFindFrom: pointer + stringFindmk: pointer + stringFindmkFrom: pointer + stringFindmkFromInPlace: pointer + stringFindn: pointer + stringFindnFrom: pointer + stringFindLast: pointer + stringFormat: pointer + stringFormatWithCustomPlaceholder: pointer + stringHexEncodeBuffer: pointer + stringHexToInt: pointer + stringHexToIntWithoutPrefix: pointer + stringInsert: pointer + stringIsNumeric: pointer + stringIsSubsequenceOf: pointer + stringIsSubsequenceOfi: pointer + stringLpad: pointer + stringLpadWithCustomCharacter: pointer + stringMatch: pointer + stringMatchn: pointer + stringMd5: pointer + stringNum: pointer + stringNumInt64: pointer + stringNumInt64Capitalized: pointer + stringNumReal: pointer + stringNumScientific: pointer + stringNumWithDecimals: pointer + stringPadDecimals: pointer + stringPadZeros: pointer + stringReplaceFirst: pointer + stringReplace: pointer + stringReplacen: pointer + stringRfind: pointer + stringRfindn: pointer + stringRfindFrom: pointer + stringRfindnFrom: pointer + stringRpad: pointer + stringRpadWithCustomCharacter: pointer + stringSimilarity: pointer + stringSprintf: pointer + stringSubstr: pointer + stringToDouble: pointer + stringToFloat: pointer + stringToInt: pointer + stringCamelcaseToUnderscore: pointer + stringCamelcaseToUnderscoreLowercased: pointer + stringCapitalize: pointer + stringCharToDouble: pointer + stringCharToInt: pointer + stringWcharToInt: pointer + stringCharToIntWithLen: pointer + stringCharToInt64WithLen: pointer + stringHexToInt64: pointer + stringHexToInt64WithPrefix: pointer + stringToInt64: pointer + stringUnicodeCharToDouble: pointer + stringGetSliceCount: pointer + stringGetSlice: pointer + stringGetSlicec: pointer + stringSplit: pointer + stringSplitAllowEmpty: pointer + stringSplitFloats: pointer + stringSplitFloatsAllowsEmpty: pointer + stringSplitFloatsMk: pointer + stringSplitFloatsMkAllowsEmpty: pointer + stringSplitInts: pointer + stringSplitIntsAllowsEmpty: pointer + stringSplitIntsMk: pointer + stringSplitIntsMkAllowsEmpty: pointer + stringSplitSpaces: pointer + stringCharLowercase: pointer + stringCharUppercase: pointer + stringToLower: pointer + stringToUpper: pointer + stringGetBasename: pointer + stringGetExtension: pointer + stringLeft: pointer + stringOrdAt: pointer + stringPlusFile: pointer + stringRight: pointer + stringStripEdges: pointer + stringStripEscapes: pointer + stringErase: pointer + stringAscii: pointer + stringAsciiExtended: pointer + stringUtf8: pointer + stringParseUtf8: pointer + stringParseUtf8WithLen: pointer + stringCharsToUtf8: pointer + stringCharsToUtf8WithLen: pointer + stringHash: pointer + stringHash64: pointer + stringHashChars: pointer + stringHashCharsWithLen: pointer + stringHashUtf8Chars: pointer + stringHashUtf8CharsWithLen: pointer + stringMd5Buffer: pointer + stringMd5Text: pointer + stringSha256Buffer: pointer + stringSha256Text: pointer + stringEmpty: pointer + stringGetBaseDir: pointer + stringGetFile: pointer + stringHumanizeSize: pointer + stringIsAbsPath: pointer + stringIsRelPath: pointer + stringIsResourceFile: pointer + stringPathTo: pointer + stringPathToFile: pointer + stringSimplifyPath: pointer + stringCEscape: pointer + stringCEscapeMultiline: pointer + stringCUnescape: pointer + stringHttpEscape: pointer + stringHttpUnescape: pointer + stringJsonEscape: pointer + stringWordWrap: pointer + stringXmlEscape: pointer + stringXmlEscapeWithQuotes: pointer + stringXmlUnescape: pointer + stringPercentDecode: pointer + stringPercentEncode: pointer + stringIsValidFloat: pointer + stringIsValidHexNumber: pointer + stringIsValidHtmlColor: pointer + stringIsValidIdentifier: pointer + stringIsValidInteger: pointer + stringIsValidIpAddress: pointer + stringDestroy: proc (self: var GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # StringName API + stringNameNew: pointer + stringNameNewData: pointer + stringNameGetName: pointer + stringNameGetHash: pointer + stringNameGetDataUniquePointer: pointer + stringNameOperatorEqual: pointer + stringNameOperatorLess: pointer + stringNameDestroy: pointer + + # Misc API + objectDestroy: proc (self: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + globalGetSingleton: proc (name: cstring): ptr GodotObject + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindGetMethod: proc (className, + methodName: cstring): ptr GodotMethodBind + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindPtrCall: proc (methodBind: ptr GodotMethodBind, + obj: ptr GodotObject, + args: ptr array[MAX_ARG_COUNT, pointer], + ret: pointer) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindCall: proc (methodBind: ptr GodotMethodBind, obj: ptr GodotObject, + args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], + argCount: cint, + callError: var VariantCallError): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + getClassConstructor: proc (className: cstring): GodotClassConstructor + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + alloc: proc (bytes: cint): pointer + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + realloc: proc (p: pointer, bytes: cint): pointer + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + free: proc (p: pointer) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + printError: proc (description, function, file: cstring, line: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + printWarning: proc (description, function, file: cstring, line: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + print: proc (message: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + GDNativeAPI* = object + # Color API + colorNewRGBA*: proc (dest: var Color, r, g, b, a: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorNewRGB*: proc (dest: var Color, r, g, b: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetR*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetR*: proc (self: var Color, r: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetG*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetG*: proc (self: var Color, g: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetB*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetB*: proc (self: var Color, b: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetA*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorSetA*: proc (self: var Color, a: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetH*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetS*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGetV*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorAsString*: proc (self: Color): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorToRGBA32*: proc (self: Color): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorAsARGB32*: proc (self: Color): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorGray*: proc (self: Color): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorInverted*: proc (self: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorContrasted*: proc (self: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorLinearInterpolate*: proc (self, other: Color, t: float32): Color + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + colorBlend*: proc (self, other: Color): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorToHtml*: proc (self: Color, withAlpha: bool): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorOperatorEqual*: proc (self, other: Color): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorOperatorLess*: proc (self, other: Color): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Vector2 API + vector2New*: proc (dest: var Vector2, x, y: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2AsString*: proc (self: Vector2): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Normalized*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Length*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Angle*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2LengthSquared*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2IsNormalized*: proc (self: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2DistanceTo*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2DistanceSquaredTo*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2AngleTo*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2AngleToPoint*: proc (self, to: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2LinearInterpolate*: proc (self, b: Vector2, t: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2CubicInterpolate*: proc (self, b, preA, postB: Vector2, + t: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2Rotated*: proc (self: Vector2, phi: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Tangent*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Floor*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Snapped*: proc (self, by: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Aspect*: proc (self: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Dot*: proc (self, other: Vector2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Slide*: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Bounce*: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Reflect*: proc (self, n: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Abs*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Clamped*: proc (self: Vector2, length: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorAdd*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorSubtract*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyVector*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyScalar*: proc (self: Vector2, scalar: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideVector*: proc (self, other: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideScalar*: proc (self: Vector2, scalar: float32): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorEqual*: proc (self, other: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorLess*: proc (self, other: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorNeg*: proc (self: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Quat API + quatNew*: proc (dest: var Quat, x, y, z, w: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatNewWithAxisAngle*: proc (dest: Quat, axis: Vector3, + angle: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetX*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetX*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetY*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetY*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetZ*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetZ*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatGetW*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSetW*: proc (self: var Quat, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatAsString*: proc (self: Quat): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatLength*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatLengthSquared*: proc (self: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatNormalized*: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatIsNormalized*: proc (self: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatInverse*: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatDot*: proc (self, other: Quat): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatXform*: proc (self: Quat, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerp*: proc (self, other: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerpni*: proc (self, other: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatCubicSlerp*: proc (self, other, preA, postB: Quat, t: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorMultiply*: proc (self: Quat, b: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorAdd*: proc (self, other: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorSubtract*: proc (self, other: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorDivide*: proc (self: Quat, divider: float32): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorEqual*: proc (self, other: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorNeg*: proc (self: Quat): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolByteArray API + poolByteArrayNew*: proc (dest: var GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayNewCopy*: proc (dest: var GodotPoolByteArray, + src: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayNewWithArray*: proc (dest: var GodotPoolByteArray, src: GodotArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayAppend*: proc (self: var GodotPoolStringArray, - val: GodotString) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolStringArrayAppendArray*: proc (self: var GodotPoolStringArray, - arr: GodotPoolStringArray) + poolByteArrayAppend*: proc (self: var GodotPoolByteArray, + val: byte) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayAppendArray*: proc (self: var GodotPoolByteArray, + arr: GodotPoolByteArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayInsert*: proc (self: var GodotPoolStringArray, - idx: cint, val: GodotString): Error - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolStringArrayInvert*: proc (self: var GodotPoolStringArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolStringArrayPushBack*: proc (self: var GodotPoolStringArray, + poolByteArrayInsert*: proc (self: var GodotPoolByteArray, + idx: cint, val: byte): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayInvert*: proc (self: var GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayPushBack*: proc (self: var GodotPoolByteArray, val: byte) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolByteArrayRemove*: proc (self: var GodotPoolByteArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayResize*: proc (self: var GodotPoolByteArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArraySet*: proc (self: var GodotPoolByteArray, idx: cint, data: byte) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayGet*: proc (self: GodotPoolByteArray, idx: cint): byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArraySize*: proc (self: GodotPoolByteArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayDestroy*: proc (self: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolIntArray API + poolIntArrayNew*: proc (dest: var GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayNewCopy*: proc (dest: var GodotPoolIntArray, + src: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayNewWithArray*: proc (dest: var GodotPoolIntArray, src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolIntArrayAppend*: proc (self: var GodotPoolIntArray, val: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayAppendArray*: proc (self: var GodotPoolIntArray, + arr: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolIntArrayInsert*: proc (self: var GodotPoolIntArray, idx: cint, + val: cint): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayInvert*: proc (self: var GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayPushBack*: proc (self: var GodotPoolIntArray, val: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayRemove*: proc (self: var GodotPoolIntArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayResize*: proc (self: var GodotPoolIntArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArraySet*: proc (self: var GodotPoolIntArray, idx: cint, data: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayGet*: proc (self: GodotPoolIntArray, idx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArraySize*: proc (self: GodotPoolIntArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayDestroy*: proc (self: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolRealArray API + poolRealArrayNew*: proc (dest: var GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayNewCopy*: proc (dest: var GodotPoolRealArray, + src: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayNewWithArray*: proc (dest: var GodotPoolRealArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayAppend*: proc (self: var GodotPoolRealArray, val: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayAppendArray*: proc (self: var GodotPoolRealArray, + arr: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayInsert*: proc (self: var GodotPoolRealArray, + idx: cint, val: float32): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayInvert*: proc (self: var GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayPushBack*: proc (self: var GodotPoolRealArray, val: float32) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolRealArrayRemove*: proc (self: var GodotPoolRealArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayResize*: proc (self: var GodotPoolRealArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArraySet*: proc (self: var GodotPoolRealArray, idx: cint, + data: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayGet*: proc (self: GodotPoolRealArray, idx: cint): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArraySize*: proc (self: GodotPoolRealArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayDestroy*: proc (self: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # PoolStringArray API + poolStringArrayNew*: proc (dest: var GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayNewCopy*: proc (dest: var GodotPoolStringArray, + src: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayNewWithArray*: proc (dest: var GodotPoolStringArray, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayAppend*: proc (self: var GodotPoolStringArray, val: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayRemove*: proc (self: var GodotPoolStringArray, idx: cint) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolStringArrayResize*: proc (self: var GodotPoolStringArray, size: cint) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolStringArrayRead: pointer - poolStringArrayWrite: pointer - poolStringArraySet*: proc (self: var GodotPoolStringArray, idx: cint, - data: GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayGet*: proc (self: GodotPoolStringArray, idx: cint): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArraySize*: proc (self: GodotPoolStringArray): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolStringArrayDestroy*: proc (self: GodotPoolStringArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - - # PoolVector2 API - poolVector2ArrayNew*: proc (dest: var GodotPoolVector2Array) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArrayNewCopy*: proc (dest: var GodotPoolVector2Array, - src: GodotPoolVector2Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayNewWithArray*: proc (dest: var GodotPoolVector2Array, - src: GodotArray) + poolStringArrayAppendArray*: proc (self: var GodotPoolStringArray, + arr: GodotPoolStringArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArrayAppend*: proc (self: var GodotPoolVector2Array, val: Vector2) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayAppendArray*: proc (self: var GodotPoolVector2Array, - arr: GodotPoolVector2Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayInsert*: proc (self: var GodotPoolVector2Array, idx: cint, - val: Vector2): Error - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayInvert*: proc (self: var GodotPoolVector2Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayPushBack*: proc (self: var GodotPoolVector2Array, - val: Vector2) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayRemove*: proc (self: var GodotPoolVector2Array, idx: cint) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayResize*: proc (self: var GodotPoolVector2Array, size: cint) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector2ArrayRead: pointer - poolVector2ArrayWrite: pointer - poolVector2ArraySet*: proc (self: var GodotPoolVector2Array, idx: cint, - data: Vector2) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArrayGet*: proc (self: GodotPoolVector2Array, idx: cint): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArraySize*: proc (self: GodotPoolVector2Array): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArrayDestroy*: proc (self: GodotPoolVector2Array) + poolStringArrayInsert*: proc (self: var GodotPoolStringArray, + idx: cint, val: GodotString): Error {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # PoolVector3 API - poolVector3ArrayNew*: proc (dest: var GodotPoolVector3Array) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector3ArrayNewCopy*: proc (dest: var GodotPoolVector3Array, - src: GodotPoolVector3Array) + poolStringArrayInvert*: proc (self: var GodotPoolStringArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector3ArrayNewWithArray*: proc (dest: var GodotPoolVector3Array, - src: GodotArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector3ArrayAppend*: proc (self: var GodotPoolVector3Array, val: Vector3) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector3ArrayAppendArray*: proc (self: var GodotPoolVector3Array, - arr: GodotPoolVector3Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector3ArrayInsert*: proc (self: var GodotPoolVector3Array, idx: cint, - val: Vector3): Error - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector3ArrayInvert*: proc (self: var GodotPoolVector3Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolVector3ArrayPushBack*: proc (self: var GodotPoolVector3Array, - val: Vector3) {.noconv, raises: [], gcsafe, - tags: [], locks: 0.} - poolVector3ArrayRemove*: proc (self: var GodotPoolVector3Array, - idx: cint) {.noconv, raises: [], gcsafe, - tags: [], locks: 0.} - poolVector3ArrayResize*: proc (self: var GodotPoolVector3Array, - size: cint) {.noconv, raises: [], gcsafe, - tags: [], locks: 0.} - poolVector3ArrayRead: pointer - poolVector3ArrayWrite: pointer - poolVector3ArraySet*: proc (self: var GodotPoolVector3Array, idx: cint, - data: Vector3) {.noconv, raises: [], gcsafe, - tags: [], locks: 0.} - poolVector3ArrayGet*: proc (self: GodotPoolVector3Array, idx: cint): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector3ArraySize*: proc (self: GodotPoolVector3Array): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector3ArrayDestroy*: proc (self: GodotPoolVector3Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - - # PoolColorArray API - poolColorArrayNew*: proc (dest: var GodotPoolColorArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayNewCopy*: proc (dest: var GodotPoolColorArray, - src: GodotPoolColorArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolColorArrayNewWithArray*: proc (dest: var GodotPoolColorArray, - src: GodotArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolColorArrayAppend*: proc (self: var GodotPoolColorArray, - val: Color) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayAppendArray*: proc (self: var GodotPoolColorArray, - arr: GodotPoolColorArray) + poolStringArrayPushBack*: proc (self: var GodotPoolStringArray, + val: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayInsert*: proc (self: var GodotPoolColorArray, - idx: cint, val: Color): Error + poolStringArrayRemove*: proc (self: var GodotPoolStringArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArrayResize*: proc (self: var GodotPoolStringArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolStringArraySet*: proc (self: var GodotPoolStringArray, idx: cint, + data: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayInvert*: proc (self: var GodotPoolColorArray) + poolStringArrayGet*: proc (self: GodotPoolStringArray, idx: cint): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayPushBack*: proc (self: var GodotPoolColorArray, val: Color) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - poolColorArrayRemove*: proc (self: var GodotPoolColorArray, idx: cint) + poolStringArraySize*: proc (self: GodotPoolStringArray): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayResize*: proc (self: var GodotPoolColorArray, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayRead: pointer - poolColorArrayWrite: pointer - poolColorArraySet*: proc (self: var GodotPoolColorArray, idx: cint, - data: Color) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayGet*: proc (self: GodotPoolColorArray, idx: cint): Color - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArraySize*: proc (self: GodotPoolColorArray): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayDestroy*: proc (self: GodotPoolColorArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - - # Pool Array Read Access API - - poolByteArrayReadAccessPtr: pointer - poolByteArrayReadAccessOperatorAssign: pointer - poolByteArrayReadAccessDestroy: pointer - poolIntArrayReadAccessPtr: pointer - poolIntArrayReadAccessOperatorAssign: pointer - poolIntArrayReadAccessDestroy: pointer - poolRealArrayReadAccessPtr: pointer - poolRealArrayReadAccessOperatorAssign: pointer - poolRealArrayReadAccessDestroy: pointer - poolStringArrayReadAccessPtr: pointer - poolStringArrayReadAccessOperatorAssign: pointer - poolStringArrayReadAccessDestroy: pointer - poolVector2ArrayReadAccessPtr: pointer - poolVector2ArrayReadAccessOperatorAssign: pointer - poolVector2ArrayReadAccessDestroy: pointer - poolVector3ArrayReadAccessPtr: pointer - poolVector3ArrayReadAccessOperatorAssign: pointer - poolVector3ArrayReadAccessDestroy: pointer - poolColorArrayReadAccessPtr: pointer - poolColorArrayReadAccessOperatorAssign: pointer - poolColorArrayReadAccessDestroy: pointer - - poolByteArrayWriteAccessPtr: pointer - poolByteArrayWriteAccessOperatorAssign: pointer - poolByteArrayWriteAccessDestroy: pointer - poolIntArrayWriteAccessPtr: pointer - poolIntArrayWriteAccessOperatorAssign: pointer - poolIntArrayWriteAccessDestroy: pointer - poolRealArrayWriteAccessPtr: pointer - poolRealArrayWriteAccessOperatorAssign: pointer - poolRealArrayWriteAccessDestroy: pointer - poolStringArrayWriteAccessPtr: pointer - poolStringArrayWriteAccessOperatorAssign: pointer - poolStringArrayWriteAccessDestroy: pointer - poolVector2ArrayWriteAccessPtr: pointer - poolVector2ArrayWriteAccessOperatorAssign: pointer - poolVector2ArrayWriteAccessDestroy: pointer - poolVector3ArrayWriteAccessPtr: pointer - poolVector3ArrayWriteAccessOperatorAssign: pointer - poolVector3ArrayWriteAccessDestroy: pointer - poolColorArrayWriteAccessPtr: pointer - poolColorArrayWriteAccessOperatorAssign: pointer - poolColorArrayWriteAccessDestroy: pointer - - # Array API - arrayNew*: proc (dest: var GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayNewCopy*: proc (dest: var GodotArray, src: GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayNewPoolColorArray*: proc (dest: var GodotArray, src: GodotPoolColorArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - arrayNewPoolVector3Array*: proc (dest: var GodotArray, - src: GodotPoolVector3Array) + poolStringArrayDestroy*: proc (self: GodotPoolStringArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayNewPoolVector2Array*: proc (dest: var GodotArray, - src: GodotPoolVector2Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - arrayNewPoolStringArray*: proc (dest: var GodotArray, - src: GodotPoolStringArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - arrayNewPoolRealArray*: proc (dest: var GodotArray, src: GodotPoolRealArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - arrayNewPoolIntArray*: proc (dest: var GodotArray, src: GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayNewPoolByteArray*: proc (dest: var GodotArray, src: GodotPoolByteArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - arraySet*: proc (self: var GodotArray, idx: cint, val: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayGet*: proc (self: GodotArray, idx: cint): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayOperatorIndex*: proc (self: var GodotArray, idx: cint): ptr GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayAppend*: proc (self: var GodotArray, val: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayClear*: proc (self: var GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayCount*: proc (self: GodotArray, val: GodotVariant): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayEmpty*: proc (self: GodotArray): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayErase*: proc (self: var GodotArray, val: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayFront*: proc (self: GodotArray): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayBack*: proc (self: GodotArray): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayFind*: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayFindLast*: proc (self: GodotArray, what: GodotVariant): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayHas*: proc (self: GodotArray, val: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayHash*: proc (self: GodotArray): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayInsert*: proc (self: var GodotArray, pos: cint, val: GodotVariant): Error - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayInvert*: proc (self: var GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayPopFront*: proc (self: GodotArray): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayPopBack*: proc (self: GodotArray): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayPushBack*: proc (self: var GodotArray, val: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayPushFront*: proc (self: var GodotArray, val: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayRemove*: proc (self: var GodotArray, idx: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayResize*: proc (self: var GodotArray, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayRFind*: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arraySize*: proc (self: GodotArray): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arraySort*: proc (self: var GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arraySortCustom*: proc (self: var GodotArray, obj: ptr GodotObject, - f: GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - arrayDestroy*: proc (self: var GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - # Dictionary API - dictionaryNew*: proc (dest: var GodotDictionary) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryNewCopy*: proc (dest: var GodotDictionary, src: GodotDictionary) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryDestroy*: proc (self: var GodotDictionary) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionarySize*: proc (self: GodotDictionary): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryEmpty*: proc (self: GodotDictionary): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryClear*: proc (self: var GodotDictionary) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryHas*: proc (self: GodotDictionary, key: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryHasAll*: proc (self: GodotDictionary, keys: GodotArray): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryErase*: proc (self: var GodotDictionary, key: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryHash*: proc (self: GodotDictionary): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryKeys*: proc (self: GodotDictionary): GodotArray - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryValues*: proc (self: GodotDictionary): GodotArray - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryGet*: proc (self: GodotDictionary, key: GodotVariant): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionarySet*: proc (self: var GodotDictionary, key, value: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryOperatorIndex*: proc (self: var GodotDictionary, - key: GodotVariant): ptr GodotVariant - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - dictionaryNext*: proc (self: GodotDictionary, - key: GodotVariant): ptr GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - dictionaryOperatorEqual*: proc (self, other: GodotDictionary): bool - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - dictionaryToJson*: proc (self: GodotDictionary): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # NodePath API - nodePathNew*: proc (dest: var GodotNodePath, src: GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathNewCopy*: proc (dest: var GodotNodePath, src: GodotNodePath) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathDestroy*: proc (self: var GodotNodePath) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathAsString*: proc (self: GodotNodePath): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathIsAbsolute*: proc (self: GodotNodePath): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathGetNameCount*: proc (self: GodotNodePath): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathGetName*: proc (self: GodotNodePath, idx: cint): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathGetSubnameCount*: proc (self: GodotNodePath): cint - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - nodePathGetSubname*: proc (self: GodotNodePath, idx: cint): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathGetProperty*: proc (self: GodotNodePath): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathIsEmpty*: proc (self: GodotNodePath): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathOperatorEqual*: proc (self, other: GodotNodePath): bool - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - - # Plane API - planeNewWithReals*: proc (dest: var Plane, a, b, c, d: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeNewWithVectors*: proc (dest: var Plane, v1, v2, v3: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeNewWithNormal*: proc (dest: var Plane, normal: Vector3, d: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeAsString*: proc (self: Plane): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeNormalized*: proc (self: Plane): Plane - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeCenter*: proc (self: Plane): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetAnyPoint*: proc (self: Plane): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeIsPointOver*: proc (self: Plane, point: Vector3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeDistanceTo*: proc (self: Plane, point: Vector3): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeHasPoint*: proc (self: Plane, point: Vector3, epsilon: float32): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeProject*: proc (self: Plane, point: Vector3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeIntersect3*: proc (self: Plane, dest: var Vector3, b, c: Plane): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeIntersectsRay*: proc (self: Plane, dest: var Vector3, - point, dir: Vector3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeIntersectsSegment*: proc (self: Plane, dest: var Vector3, - segmentBegin, segmentEnd: Vector3): bool - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - planeOperatorNeg*: proc (self: Plane): Plane - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeOperatorEqual*: proc (self, other: Plane): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeSetNormal*: proc (self: var Plane, normal: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetNormal*: proc (self: Plane): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetD*: proc (self: Plane): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeSetD*: proc (self: var Plane, d: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # Rect2 API - rect2NewWithPositionAndSize*: proc (dest: var Rect2, pos, size: Vector2) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - rect2New*: proc (dest: var Rect2, x, y, width, height: float32) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2AsString*: proc (self: Rect2): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetArea*: proc (self: Rect2): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Intersects*: proc (self, other: Rect2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Encloses*: proc (self, other: Rect2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2HasNoArea*: proc (self: Rect2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Clip*: proc (self, other: Rect2): Rect2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Merge*: proc (self, other: Rect2): Rect2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2HasPoint*: proc (self: Rect2, point: Vector2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Grow*: proc (self: Rect2, by: float32): Rect2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Expand*: proc (self: Rect2, to: Vector2): Rect2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2OperatorEqual*: proc (self, other: Rect2): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetPosition*: proc (self: Rect2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetSize*: proc (self: Rect2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2SetPosition*: proc (self: var Rect2, pos: Vector2) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2SetSize*: proc (self: var Rect2, size: Vector2) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # Rect3 API - rect3New*: proc (dest: var Rect3, pos, size: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetPosition*: proc (self: Rect3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3SetPosition*: proc (self: var Rect3, pos: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetSize*: proc (self: Rect3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3SetSize*: proc (self: var Rect3, pos: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3AsString*: proc (self: Rect3): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetArea*: proc (self: Rect3): float32 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasNoArea*: proc (self: Rect3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasNoSurface*: proc (self: Rect3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Intersects*: proc (self, other: Rect3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Encloses*: proc (self, other: Rect3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Merge*: proc (self, other: Rect3): Rect3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Intersection*: proc (self, other: Rect3): Rect3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3IntersectsPlane*: proc (self: Rect3, plane: Plane): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3IntersectsSegment*: proc (self: Rect3, vFrom, vTo: Vector3): bool - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - rect3HasPoint*: proc (self: Rect3, point: Vector3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetSupport*: proc (self: Rect3, dir: Vector3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxis*: proc (self: Rect3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxisIndex*: proc (self: Rect3): cint - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - rect3GetLongestAxisSize*: proc (self: Rect3): float32 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - rect3GetShortestAxis*: proc (self: Rect3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxisIndex*: proc (self: Rect3): cint + # PoolVector2 API + poolVector2ArrayNew*: proc (dest: var GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayNewCopy*: proc (dest: var GodotPoolVector2Array, + src: GodotPoolVector2Array) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxisSize*: proc (self: Rect3): float32 + poolVector2ArrayNewWithArray*: proc (dest: var GodotPoolVector2Array, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayAppend*: proc (self: var GodotPoolVector2Array, val: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Expand*: proc (self: Rect3, toPoint: Vector3): Rect3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Grow*: proc (self: Rect3, by: float32): Rect3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetEndpoint*: proc (self: Rect3, idx: cint): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3OperatorEqual*: proc (self, other: Rect3): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # RID API - ridNew*: proc (dest: var RID) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - ridGetID*: proc (self: RID): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - ridNewWithResource*: proc (dest: var RID, obj: ptr GodotObject) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - ridOperatorEqual*: proc (self, other: RID): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - ridOperatorLess*: proc (self, other: RID): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # Transform API - transformNewWithAxisOrigin*: proc (dest: var Transform, - xAxis, yAxis, zAxis, origin: Vector3) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformNew*: proc (dest: var Transform, basis: Basis, origin: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformGetBasis*: proc (self: Transform): Basis - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformSetBasis*: proc (self: var Transform, basis: Basis) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformGetOrigin*: proc (self: Transform): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformSetOrigin*: proc (self: var Transform, v: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformAsString*: proc (self: Transform): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformInverse*: proc (self: Transform): Transform - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformAffineInverse*: proc (self: Transform): Transform - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformOrthonormalized*: proc (self: Transform): Transform - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformRotated*: proc (self: Transform, axis: Vector3, - phi: float32): Transform - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformScaled*: proc (self: Transform, scale: Vector3): Transform - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformTranslated*: proc (self: Transform, offset: Vector3): Transform - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformLookingAt*: proc (self: Transform, target, up: Vector3): Transform - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformPlane*: proc (self: Transform, plane: Plane): Plane - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvPlane*: proc (self: Transform, plane: Plane): Plane - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformNewIdentity*: proc (dest: var Transform) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformOperatorEqual*: proc (self, other: Transform): bool - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformOperatorMultiply*: proc (self, other: Transform): Transform - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformXformVector3*: proc (self: Transform, v: Vector3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transformXformRect3*: proc (self: Transform, v: Rect3): Rect3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvRect3*: proc (self: Transform, v: Rect3): Rect3 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - - # Transform2D API - transform2DNew*: proc (dest: var Transform2D, rot: float32, pos: Vector2) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DNewAxisOrigin*: proc (dest: var Transform2D, - xAxis, yAxis, origin: Vector2) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DAsString*: proc (self: Transform2D): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DInverse*: proc (self: Transform2D): Transform2D - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DAffineInverse*: proc (self: Transform2D): Transform2D - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DGetRotation*: proc (self: Transform2D): float32 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DGetOrigin*: proc (self: Transform2D): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DGetScale*: proc (self: Transform2D): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DOrthonormalized*: proc (self: Transform2D): Transform2D - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DRotated*: proc (self: Transform2D, phi: float32): Transform2D - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DScaled*: proc (self: Transform2D, scale: Vector2): Transform2D - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DTranslated*: proc (self: Transform2D, offset: Vector2): Transform2D - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DXformInvVector2*: proc (self: Transform2D, v: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DBasisXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DBasisXformInvVector2*: proc (self: Transform2D, - v: Vector2): Vector2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DInterpolateWith*: proc (self, other: Transform2D, - t: float32): Transform2D - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DOperatorEqual*: proc (self, other: Transform2D): bool - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DOperatorMultiply*: proc (self, other: Transform2D): Transform2D - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DNewIdentity*: proc (dest: var Transform2D) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DXformRect2*: proc (self: Transform2D, v: Rect2): Rect2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - transform2DXformInvRect2*: proc (self: Transform2D, v: Rect2): Rect2 - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - - # Variant API - variantGetType*: proc (v: GodotVariant): VariantType - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewCopy*: proc (dest: var GodotVariant, src: GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewNil*: proc (dest: var GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewBool*: proc (dest: var GodotVariant, val: bool) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewUInt*: proc (dest: var GodotVariant, val: uint64) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewInt*: proc (dest: var GodotVariant, val: int64) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewReal*: proc (dest: var GodotVariant, val: float64) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewString*: proc (dest: var GodotVariant, val: GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewVector2*: proc (dest: var GodotVariant, val: Vector2) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewRect2*: proc (dest: var GodotVariant, val: Rect2) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewVector3*: proc (dest: var GodotVariant, val: Vector3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewTransform2D*: proc (dest: var GodotVariant, val: Transform2D) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPlane*: proc (dest: var GodotVariant, val: Plane) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewQuat*: proc (dest: var GodotVariant, val: Quat) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewRect3*: proc (dest: var GodotVariant, val: Rect3) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewBasis*: proc (dest: var GodotVariant, val: Basis) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewTransform*: proc (dest: var GodotVariant, val: Transform) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewColor*: proc (dest: var GodotVariant, val: Color) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewNodePath*: proc (dest: var GodotVariant, val: GodotNodePath) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewRID*: proc (dest: var GodotVariant, val: RID) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewObject*: proc (dest: var GodotVariant, val: ptr GodotObject) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewDictionary*: proc (dest: var GodotVariant, val: GodotDictionary) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewArray*: proc (dest: var GodotVariant, val: GodotArray) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewPoolByteArray*: proc (dest: var GodotVariant, - val: GodotPoolByteArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPoolIntArray*: proc (dest: var GodotVariant, val: GodotPoolIntArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPoolRealArray*: proc (dest: var GodotVariant, - val: GodotPoolRealArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPoolStringArray*: proc (dest: var GodotVariant, - val: GodotPoolStringArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPoolVector2Array*: proc (dest: var GodotVariant, - val: GodotPoolVector2Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPoolVector3Array*: proc (dest: var GodotVariant, - val: GodotPoolVector3Array) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantNewPoolColorArray*: proc (dest: var GodotVariant, - val: GodotPoolColorArray) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsBool*: proc (self: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsUInt*: proc (self: GodotVariant): uint64 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsInt*: proc (self: GodotVariant): int64 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsReal*: proc (self: GodotVariant): float64 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsString*: proc (self: GodotVariant): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsVector2*: proc (self: GodotVariant): Vector2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRect2*: proc (self: GodotVariant): Rect2 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsVector3*: proc (self: GodotVariant): Vector3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsTransform2D*: proc (self: GodotVariant): Transform2D - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsPlane*: proc (self: GodotVariant): Plane - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsQuat*: proc (self: GodotVariant): Quat - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRect3*: proc (self: GodotVariant): Rect3 - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsBasis*: proc (self: GodotVariant): Basis - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsTransform*: proc (self: GodotVariant): Transform - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsColor*: proc (self: GodotVariant): Color - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsNodePath*: proc (self: GodotVariant): GodotNodePath - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRID*: proc (self: GodotVariant): RID - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsObject*: proc (self: GodotVariant): ptr GodotObject - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsDictionary*: proc (self: GodotVariant): GodotDictionary - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsArray*: proc (self: GodotVariant): GodotArray - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsPoolByteArray*: proc (self: GodotVariant): GodotPoolByteArray - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsPoolIntArray*: proc (self: GodotVariant): GodotPoolIntArray - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsPoolRealArray*: proc (self: GodotVariant): GodotPoolRealArray - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsPoolStringArray*: proc (self: GodotVariant): GodotPoolStringArray - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsPoolVector2Array*: proc (self: GodotVariant): GodotPoolVector2Array - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsPoolVector3Array*: proc (self: GodotVariant): GodotPoolVector3Array - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantAsPoolColorArray*: proc (self: GodotVariant): GodotPoolColorArray - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - variantCall*: proc (self: var GodotVariant, meth: GodotString, - args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], - argcount: cint, - callError: var VariantCallError): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantHasMethod*: proc (self: GodotVariant, meth: GodotString): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantOperatorEqual*: proc (self, other: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantOperatorLess*: proc (self, other: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantHashCompare*: proc (self, other: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantBooleanize*: proc (self: GodotVariant): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantDestroy*: proc (self: var GodotVariant) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # String API - stringNew*: proc (dest: var GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringNewCopy*: proc (dest: var GodotString, src: GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringNewData*: proc (dest: var GodotString, contents: cstring, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringNewUTF16Data: pointer - stringGetData*: proc (self: GodotString, dest: cstring, size: var cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringOperatorIndex: pointer - stringCStr*: proc (self: GodotString): cstring - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringOperatorIndexConst: pointer - stringUTF16Str: pointer - stringOperatorEqual*: proc (self, other: GodotString): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringOperatorLess*: proc (self, other: GodotString): bool - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringOperatorPlus*: proc (self, other: GodotString): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringLength*: proc (self: GodotString): cint - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringBeginsWith: pointer - stringBeginsWithCharArray: pointer - stringBigrams: pointer - stringChr: pointer - stringEndsWith: pointer - stringFind: pointer - stringFindFrom: pointer - stringFindmk: pointer - stringFindmkFrom: pointer - stringFindmkFromInPlace: pointer - stringFindn: pointer - stringFindnFrom: pointer - stringFindLast: pointer - stringFormat: pointer - stringFormatWithCustomPlaceholder: pointer - stringHexEncodeBuffer: pointer - stringHexToInt: pointer - stringHexToIntWithoutPrefix: pointer - stringInsert: pointer - stringIsNumeric: pointer - stringIsSubsequenceOf: pointer - stringIsSubsequenceOfi: pointer - stringLpad: pointer - stringLpadWithCustomCharacter: pointer - stringMatch: pointer - stringMatchn: pointer - stringMd5: pointer - stringNum: pointer - stringNumInt64: pointer - stringNumInt64Capitalized: pointer - stringNumReal: pointer - stringNumScientific: pointer - stringNumWithDecimals: pointer - stringPadDecimals: pointer - stringPadZeros: pointer - stringReplaceFirst: pointer - stringReplace: pointer - stringReplacen: pointer - stringRfind: pointer - stringRfindn: pointer - stringRfindFrom: pointer - stringRfindnFrom: pointer - stringRpad: pointer - stringRpadWithCustomCharacter: pointer - stringSimilarity: pointer - stringSprintf: pointer - stringSubstr: pointer - stringToDouble: pointer - stringToFloat: pointer - stringToInt: pointer - stringCamelcaseToUnderscore: pointer - stringCamelcaseToUnderscoreLowercased: pointer - stringCapitalize: pointer - stringCharToDouble: pointer - stringCharToInt: pointer - stringWcharToInt: pointer - stringCharToIntWithLen: pointer - stringCharToInt64WithLen: pointer - stringHexToInt64: pointer - stringHexToInt64WithPrefix: pointer - stringToInt64: pointer - stringUnicodeCharToDouble: pointer - stringGetSliceCount: pointer - stringGetSlice: pointer - stringGetSlicec: pointer - stringSplit: pointer - stringSplitAllowEmpty: pointer - stringSplitFloats: pointer - stringSplitFloatsAllowsEmpty: pointer - stringSplitFloatsMk: pointer - stringSplitFloatsMkAllowsEmpty: pointer - stringSplitInts: pointer - stringSplitIntsAllowsEmpty: pointer - stringSplitIntsMk: pointer - stringSplitIntsMkAllowsEmpty: pointer - stringSplitSpaces: pointer - stringCharLowercase: pointer - stringCharUppercase: pointer - stringToLower: pointer - stringToUpper: pointer - stringGetBasename: pointer - stringGetExtension: pointer - stringLeft: pointer - stringOrdAt: pointer - stringPlusFile: pointer - stringRight: pointer - stringStripEdges: pointer - stringStripEscapes: pointer - stringErase: pointer - stringAscii: pointer - stringAsciiExtended: pointer - stringUtf8: pointer - stringParseUtf8: pointer - stringParseUtf8WithLen: pointer - stringCharsToUtf8: pointer - stringCharsToUtf8WithLen: pointer - stringHash: pointer - stringHash64: pointer - stringHashChars: pointer - stringHashCharsWithLen: pointer - stringHashUtf8Chars: pointer - stringHashUtf8CharsWithLen: pointer - stringMd5Buffer: pointer - stringMd5Text: pointer - stringSha256Buffer: pointer - stringSha256Text: pointer - stringEmpty: pointer - stringGetBaseDir: pointer - stringGetFile: pointer - stringHumanizeSize: pointer - stringIsAbsPath: pointer - stringIsRelPath: pointer - stringIsResourceFile: pointer - stringPathTo: pointer - stringPathToFile: pointer - stringSimplifyPath: pointer - stringCEscape: pointer - stringCEscapeMultiline: pointer - stringCUnescape: pointer - stringHttpEscape: pointer - stringHttpUnescape: pointer - stringJsonEscape: pointer - stringWordWrap: pointer - stringXmlEscape: pointer - stringXmlEscapeWithQuotes: pointer - stringXmlUnescape: pointer - stringPercentDecode: pointer - stringPercentEncode: pointer - stringIsValidFloat: pointer - stringIsValidHexNumber: pointer - stringIsValidHtmlColor: pointer - stringIsValidIdentifier: pointer - stringIsValidInteger: pointer - stringIsValidIpAddress: pointer - stringDestroy*: proc (self: var GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # StringName API - stringNameNew: pointer - stringNameNewData: pointer - stringNameGetName: pointer - stringNameGetHash: pointer - stringNameGetDataUniquePointer: pointer - stringNameOperatorEqual: pointer - stringNameOperatorLess: pointer - stringNameDestroy: pointer - - # Misc API - objectDestroy*: proc (self: ptr GodotObject) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - globalGetSingleton*: proc (name: cstring): ptr GodotObject - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - methodBindGetMethod*: proc (className, - methodName: cstring): ptr GodotMethodBind - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - methodBindPtrCall*: proc (methodBind: ptr GodotMethodBind, - obj: ptr GodotObject, - args: ptr array[MAX_ARG_COUNT, pointer], - ret: pointer) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - methodBindCall*: proc (methodBind: ptr GodotMethodBind, obj: ptr GodotObject, - args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], - argCount: cint, - callError: var VariantCallError): GodotVariant - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - getClassConstructor*: proc (className: cstring): GodotClassConstructor - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - alloc*: proc (bytes: cint): pointer - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - realloc*: proc (p: pointer, bytes: cint): pointer - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - free*: proc (p: pointer) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - printError*: proc (description, function, file: cstring, line: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - printWarning*: proc (description, function, file: cstring, line: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - print*: proc (message: GodotString) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - - # NativeScript API - nativeScriptRegisterClass*: proc (gdnativeHandle: pointer, - name, base: cstring, - createFunc: GodotInstanceCreateFunc, - destroyFunc: GodotInstanceDestroyFunc) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - nativeScriptRegisterToolClass*: proc (gdnativeHandle: pointer, - name, base: cstring, - createFunc: GodotInstanceCreateFunc, - destroyFunc: GodotInstanceDestroyFunc) + poolVector2ArrayAppendArray*: proc (self: var GodotPoolVector2Array, + arr: GodotPoolVector2Array) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nativeScriptRegisterMethod*: proc (gdnativeHandle: pointer, - name, functionName: cstring, - attr: GodotMethodAttributes, - meth: GodotInstanceMethod) + poolVector2ArrayInsert*: proc (self: var GodotPoolVector2Array, idx: cint, + val: Vector2): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayInvert*: proc (self: var GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayPushBack*: proc (self: var GodotPoolVector2Array, + val: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nativeScriptRegisterProperty*: proc (gdnativeHandle: pointer, - name, path: cstring, - attr: ptr GodotPropertyAttributes, - setFunc: GodotPropertySetFunc, - getFunc: GodotPropertyGetFunc) + poolVector2ArrayRemove*: proc (self: var GodotPoolVector2Array, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArrayResize*: proc (self: var GodotPoolVector2Array, size: cint) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector2ArraySet*: proc (self: var GodotPoolVector2Array, idx: cint, + data: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayGet*: proc (self: GodotPoolVector2Array, idx: cint): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArraySize*: proc (self: GodotPoolVector2Array): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayDestroy*: proc (self: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolVector3 API + poolVector3ArrayNew*: proc (dest: var GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayNewCopy*: proc (dest: var GodotPoolVector3Array, + src: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayNewWithArray*: proc (dest: var GodotPoolVector3Array, + src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayAppend*: proc (self: var GodotPoolVector3Array, val: Vector3) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayAppendArray*: proc (self: var GodotPoolVector3Array, + arr: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayInsert*: proc (self: var GodotPoolVector3Array, idx: cint, + val: Vector3): Error + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayInvert*: proc (self: var GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolVector3ArrayPushBack*: proc (self: var GodotPoolVector3Array, + val: Vector3) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayRemove*: proc (self: var GodotPoolVector3Array, + idx: cint) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayResize*: proc (self: var GodotPoolVector3Array, + size: cint) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArraySet*: proc (self: var GodotPoolVector3Array, idx: cint, + data: Vector3) {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} + poolVector3ArrayGet*: proc (self: GodotPoolVector3Array, idx: cint): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArraySize*: proc (self: GodotPoolVector3Array): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayDestroy*: proc (self: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # PoolColorArray API + poolColorArrayNew*: proc (dest: var GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayNewCopy*: proc (dest: var GodotPoolColorArray, + src: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayNewWithArray*: proc (dest: var GodotPoolColorArray, + src: GodotArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nativeScriptRegisterSignal*: proc (gdnativeHandle: pointer, name: cstring, - signal: GodotSignal) - {.noconv, raises: [], gcsafe, tags: [], - locks: 0.} - nativeScriptGetUserdata*: proc (obj: ptr GodotObject): pointer + poolColorArrayAppend*: proc (self: var GodotPoolColorArray, + val: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayAppendArray*: proc (self: var GodotPoolColorArray, + arr: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayInsert*: proc (self: var GodotPoolColorArray, + idx: cint, val: Color): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayInvert*: proc (self: var GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayPushBack*: proc (self: var GodotPoolColorArray, val: Color) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + poolColorArrayRemove*: proc (self: var GodotPoolColorArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayResize*: proc (self: var GodotPoolColorArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArraySet*: proc (self: var GodotPoolColorArray, idx: cint, + data: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayGet*: proc (self: GodotPoolColorArray, idx: cint): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArraySize*: proc (self: GodotPoolColorArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayDestroy*: proc (self: GodotPoolColorArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + # Array API + arrayNew*: proc (dest: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewCopy*: proc (dest: var GodotArray, src: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewPoolColorArray*: proc (dest: var GodotArray, src: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolVector3Array*: proc (dest: var GodotArray, + src: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolVector2Array*: proc (dest: var GodotArray, + src: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolStringArray*: proc (dest: var GodotArray, + src: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolRealArray*: proc (dest: var GodotArray, src: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arrayNewPoolIntArray*: proc (dest: var GodotArray, src: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayNewPoolByteArray*: proc (dest: var GodotArray, src: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + arraySet*: proc (self: var GodotArray, idx: cint, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayGet*: proc (self: GodotArray, idx: cint): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayOperatorIndex*: proc (self: var GodotArray, idx: cint): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayAppend*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayClear*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayCount*: proc (self: GodotArray, val: GodotVariant): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayEmpty*: proc (self: GodotArray): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayErase*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFront*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBack*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFind*: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayFindLast*: proc (self: GodotArray, what: GodotVariant): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayHas*: proc (self: GodotArray, val: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayHash*: proc (self: GodotArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayInsert*: proc (self: var GodotArray, pos: cint, val: GodotVariant): Error + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayInvert*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPopFront*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPopBack*: proc (self: GodotArray): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPushBack*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayPushFront*: proc (self: var GodotArray, val: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayRemove*: proc (self: var GodotArray, idx: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayResize*: proc (self: var GodotArray, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayRFind*: proc (self: GodotArray, what: GodotVariant, fromIdx: cint): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySize*: proc (self: GodotArray): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySort*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arraySortCustom*: proc (self: var GodotArray, obj: ptr GodotObject, + f: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayDestroy*: proc (self: var GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + # Dictionary API + dictionaryNew*: proc (dest: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryNewCopy*: proc (dest: var GodotDictionary, src: GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryDestroy*: proc (self: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionarySize*: proc (self: GodotDictionary): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryEmpty*: proc (self: GodotDictionary): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryClear*: proc (self: var GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHas*: proc (self: GodotDictionary, key: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHasAll*: proc (self: GodotDictionary, keys: GodotArray): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryErase*: proc (self: var GodotDictionary, key: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryHash*: proc (self: GodotDictionary): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryKeys*: proc (self: GodotDictionary): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryValues*: proc (self: GodotDictionary): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryGet*: proc (self: GodotDictionary, key: GodotVariant): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionarySet*: proc (self: var GodotDictionary, key, value: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryOperatorIndex*: proc (self: var GodotDictionary, + key: GodotVariant): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + dictionaryNext*: proc (self: GodotDictionary, + key: GodotVariant): ptr GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + dictionaryOperatorEqual*: proc (self, other: GodotDictionary): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + dictionaryToJson*: proc (self: GodotDictionary): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} -var gdNativeAPI: ptr GDNativeAPI + # NodePath API + nodePathNew*: proc (dest: var GodotNodePath, src: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathNewCopy*: proc (dest: var GodotNodePath, src: GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathDestroy*: proc (self: var GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathAsString*: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathIsAbsolute*: proc (self: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetNameCount*: proc (self: GodotNodePath): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetName*: proc (self: GodotNodePath, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetSubnameCount*: proc (self: GodotNodePath): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nodePathGetSubname*: proc (self: GodotNodePath, idx: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetProperty*: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathIsEmpty*: proc (self: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathOperatorEqual*: proc (self, other: GodotNodePath): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Plane API + planeNewWithReals*: proc (dest: var Plane, a, b, c, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNewWithVectors*: proc (dest: var Plane, v1, v2, v3: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNewWithNormal*: proc (dest: var Plane, normal: Vector3, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeAsString*: proc (self: Plane): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeNormalized*: proc (self: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeCenter*: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetAnyPoint*: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIsPointOver*: proc (self: Plane, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeDistanceTo*: proc (self: Plane, point: Vector3): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeHasPoint*: proc (self: Plane, point: Vector3, epsilon: float32): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeProject*: proc (self: Plane, point: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersect3*: proc (self: Plane, dest: var Vector3, b, c: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersectsRay*: proc (self: Plane, dest: var Vector3, + point, dir: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeIntersectsSegment*: proc (self: Plane, dest: var Vector3, + segmentBegin, segmentEnd: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + planeOperatorNeg*: proc (self: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeOperatorEqual*: proc (self, other: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeSetNormal*: proc (self: var Plane, normal: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetNormal*: proc (self: Plane): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetD*: proc (self: Plane): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeSetD*: proc (self: var Plane, d: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Rect2 API + rect2NewWithPositionAndSize*: proc (dest: var Rect2, pos, size: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect2New*: proc (dest: var Rect2, x, y, width, height: float32) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2AsString*: proc (self: Rect2): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetArea*: proc (self: Rect2): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Intersects*: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Encloses*: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2HasNoArea*: proc (self: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Clip*: proc (self, other: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Merge*: proc (self, other: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2HasPoint*: proc (self: Rect2, point: Vector2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Grow*: proc (self: Rect2, by: float32): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2Expand*: proc (self: Rect2, to: Vector2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2OperatorEqual*: proc (self, other: Rect2): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetPosition*: proc (self: Rect2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetSize*: proc (self: Rect2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2SetPosition*: proc (self: var Rect2, pos: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2SetSize*: proc (self: var Rect2, size: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Rect3 API + rect3New*: proc (dest: var Rect3, pos, size: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetPosition*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3SetPosition*: proc (self: var Rect3, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetSize*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3SetSize*: proc (self: var Rect3, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3AsString*: proc (self: Rect3): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetArea*: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3HasNoArea*: proc (self: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3HasNoSurface*: proc (self: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Intersects*: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Encloses*: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Merge*: proc (self, other: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Intersection*: proc (self, other: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3IntersectsPlane*: proc (self: Rect3, plane: Plane): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3IntersectsSegment*: proc (self: Rect3, vFrom, vTo: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3HasPoint*: proc (self: Rect3, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetSupport*: proc (self: Rect3, dir: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetLongestAxis*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetLongestAxisIndex*: proc (self: Rect3): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetLongestAxisSize*: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetShortestAxis*: proc (self: Rect3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetShortestAxisIndex*: proc (self: Rect3): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3GetShortestAxisSize*: proc (self: Rect3): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + rect3Expand*: proc (self: Rect3, toPoint: Vector3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3Grow*: proc (self: Rect3, by: float32): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3GetEndpoint*: proc (self: Rect3, idx: cint): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect3OperatorEqual*: proc (self, other: Rect3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # RID API + ridNew*: proc (dest: var RID) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridGetID*: proc (self: RID): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridNewWithResource*: proc (dest: var RID, obj: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridOperatorEqual*: proc (self, other: RID): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + ridOperatorLess*: proc (self, other: RID): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Transform API + transformNewWithAxisOrigin*: proc (dest: var Transform, + xAxis, yAxis, zAxis, origin: Vector3) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformNew*: proc (dest: var Transform, basis: Basis, origin: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformGetBasis*: proc (self: Transform): Basis + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetBasis*: proc (self: var Transform, basis: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformGetOrigin*: proc (self: Transform): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetOrigin*: proc (self: var Transform, v: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAsString*: proc (self: Transform): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformInverse*: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAffineInverse*: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOrthonormalized*: proc (self: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformRotated*: proc (self: Transform, axis: Vector3, + phi: float32): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformScaled*: proc (self: Transform, scale: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformTranslated*: proc (self: Transform, offset: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformLookingAt*: proc (self: Transform, target, up: Vector3): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformPlane*: proc (self: Transform, plane: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvPlane*: proc (self: Transform, plane: Plane): Plane + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformNewIdentity*: proc (dest: var Transform) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformOperatorEqual*: proc (self, other: Transform): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOperatorMultiply*: proc (self, other: Transform): Transform + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformVector3*: proc (self: Transform, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformRect3*: proc (self: Transform, v: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvRect3*: proc (self: Transform, v: Rect3): Rect3 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Transform2D API + transform2DNew*: proc (dest: var Transform2D, rot: float32, pos: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DNewAxisOrigin*: proc (dest: var Transform2D, + xAxis, yAxis, origin: Vector2) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DAsString*: proc (self: Transform2D): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DInverse*: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DAffineInverse*: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DGetRotation*: proc (self: Transform2D): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DGetOrigin*: proc (self: Transform2D): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DGetScale*: proc (self: Transform2D): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DOrthonormalized*: proc (self: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DRotated*: proc (self: Transform2D, phi: float32): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DScaled*: proc (self: Transform2D, scale: Vector2): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DTranslated*: proc (self: Transform2D, offset: Vector2): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvVector2*: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformInvVector2*: proc (self: Transform2D, + v: Vector2): Vector2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DInterpolateWith*: proc (self, other: Transform2D, + t: float32): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DOperatorEqual*: proc (self, other: Transform2D): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DOperatorMultiply*: proc (self, other: Transform2D): Transform2D + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DNewIdentity*: proc (dest: var Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformRect2*: proc (self: Transform2D, v: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvRect2*: proc (self: Transform2D, v: Rect2): Rect2 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + + # Variant API + variantGetType*: proc (v: GodotVariant): VariantType + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewCopy*: proc (dest: var GodotVariant, src: GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewNil*: proc (dest: var GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewBool*: proc (dest: var GodotVariant, val: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewUInt*: proc (dest: var GodotVariant, val: uint64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewInt*: proc (dest: var GodotVariant, val: int64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewReal*: proc (dest: var GodotVariant, val: float64) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewString*: proc (dest: var GodotVariant, val: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewVector2*: proc (dest: var GodotVariant, val: Vector2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRect2*: proc (dest: var GodotVariant, val: Rect2) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewVector3*: proc (dest: var GodotVariant, val: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewTransform2D*: proc (dest: var GodotVariant, val: Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPlane*: proc (dest: var GodotVariant, val: Plane) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewQuat*: proc (dest: var GodotVariant, val: Quat) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRect3*: proc (dest: var GodotVariant, val: Rect3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewBasis*: proc (dest: var GodotVariant, val: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewTransform*: proc (dest: var GodotVariant, val: Transform) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewColor*: proc (dest: var GodotVariant, val: Color) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewNodePath*: proc (dest: var GodotVariant, val: GodotNodePath) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewRID*: proc (dest: var GodotVariant, val: RID) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewObject*: proc (dest: var GodotVariant, val: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewDictionary*: proc (dest: var GodotVariant, val: GodotDictionary) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewArray*: proc (dest: var GodotVariant, val: GodotArray) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantNewPoolByteArray*: proc (dest: var GodotVariant, + val: GodotPoolByteArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolIntArray*: proc (dest: var GodotVariant, val: GodotPoolIntArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolRealArray*: proc (dest: var GodotVariant, + val: GodotPoolRealArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolStringArray*: proc (dest: var GodotVariant, + val: GodotPoolStringArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolVector2Array*: proc (dest: var GodotVariant, + val: GodotPoolVector2Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolVector3Array*: proc (dest: var GodotVariant, + val: GodotPoolVector3Array) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantNewPoolColorArray*: proc (dest: var GodotVariant, + val: GodotPoolColorArray) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsBool*: proc (self: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsUInt*: proc (self: GodotVariant): uint64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsInt*: proc (self: GodotVariant): int64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsReal*: proc (self: GodotVariant): float64 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsString*: proc (self: GodotVariant): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector2*: proc (self: GodotVariant): Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect2*: proc (self: GodotVariant): Rect2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector3*: proc (self: GodotVariant): Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform2D*: proc (self: GodotVariant): Transform2D + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPlane*: proc (self: GodotVariant): Plane + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsQuat*: proc (self: GodotVariant): Quat + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect3*: proc (self: GodotVariant): Rect3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsBasis*: proc (self: GodotVariant): Basis + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform*: proc (self: GodotVariant): Transform + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsColor*: proc (self: GodotVariant): Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsNodePath*: proc (self: GodotVariant): GodotNodePath + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRID*: proc (self: GodotVariant): RID + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsObject*: proc (self: GodotVariant): ptr GodotObject + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsDictionary*: proc (self: GodotVariant): GodotDictionary + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsArray*: proc (self: GodotVariant): GodotArray + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPoolByteArray*: proc (self: GodotVariant): GodotPoolByteArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolIntArray*: proc (self: GodotVariant): GodotPoolIntArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolRealArray*: proc (self: GodotVariant): GodotPoolRealArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolStringArray*: proc (self: GodotVariant): GodotPoolStringArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolVector2Array*: proc (self: GodotVariant): GodotPoolVector2Array + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolVector3Array*: proc (self: GodotVariant): GodotPoolVector3Array + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantAsPoolColorArray*: proc (self: GodotVariant): GodotPoolColorArray + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + variantCall*: proc (self: var GodotVariant, meth: GodotString, + args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], + argcount: cint, + callError: var VariantCallError): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantHasMethod*: proc (self: GodotVariant, meth: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantOperatorEqual*: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantOperatorLess*: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantHashCompare*: proc (self, other: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantBooleanize*: proc (self: GodotVariant): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantDestroy*: proc (self: var GodotVariant) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # String API + stringNew*: proc (dest: var GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewCopy*: proc (dest: var GodotString, src: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewData*: proc (dest: var GodotString, contents: cstring, size: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringGetData*: proc (self: GodotString, dest: cstring, size: var cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringCStr*: proc (self: GodotString): cstring + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorEqual*: proc (self, other: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorLess*: proc (self, other: GodotString): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringOperatorPlus*: proc (self, other: GodotString): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringLength*: proc (self: GodotString): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringDestroy*: proc (self: var GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + # Misc API + objectDestroy*: proc (self: ptr GodotObject) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + globalGetSingleton*: proc (name: cstring): ptr GodotObject + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindGetMethod*: proc (className, + methodName: cstring): ptr GodotMethodBind + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindPtrCall*: proc (methodBind: ptr GodotMethodBind, + obj: ptr GodotObject, + args: ptr array[MAX_ARG_COUNT, pointer], + ret: pointer) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + methodBindCall*: proc (methodBind: ptr GodotMethodBind, obj: ptr GodotObject, + args: ptr array[MAX_ARG_COUNT, ptr GodotVariant], + argCount: cint, + callError: var VariantCallError): GodotVariant + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + getClassConstructor*: proc (className: cstring): GodotClassConstructor + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + alloc*: proc (bytes: cint): pointer + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + realloc*: proc (p: pointer, bytes: cint): pointer + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + free*: proc (p: pointer) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + printError*: proc (description, function, file: cstring, line: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + printWarning*: proc (description, function, file: cstring, line: cint) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + print*: proc (message: GodotString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + nativeScriptRegisterClass*: proc (gdnativeHandle: pointer, + name, base: cstring, + createFunc: GodotInstanceCreateFunc, + destroyFunc: GodotInstanceDestroyFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterToolClass*: proc (gdnativeHandle: pointer, + name, base: cstring, + createFunc: GodotInstanceCreateFunc, + destroyFunc: GodotInstanceDestroyFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterMethod*: proc (gdnativeHandle: pointer, + name, functionName: cstring, + attr: GodotMethodAttributes, + meth: GodotInstanceMethod) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterProperty*: proc (gdnativeHandle: pointer, + name, path: cstring, + attr: ptr GodotPropertyAttributes, + setFunc: GodotPropertySetFunc, + getFunc: GodotPropertyGetFunc) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptRegisterSignal*: proc (gdnativeHandle: pointer, name: cstring, + signal: GodotSignal) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + nativeScriptGetUserdata*: proc (obj: ptr GodotObject): pointer + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + +macro assign(dest, src: typed, values: untyped): typed = + result = newStmtList() + for val in values: + result.add(newNimNode(nnkAsgn).add( + newNimNode(nnkDotExpr).add(dest, val), + newNimNode(nnkDotExpr).add(src, val))) + +var gdNativeAPI: GDNativeAPI proc getGDNativeAPI*(): ptr GDNativeAPI {.inline.} = - gdNativeAPI + addr gdNativeAPI proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = - gdNativeAPI = cast[ptr GDNativeAPI](apiStruct) + let header = cast[ptr GDNativeAPIHeader](apiStruct) + + if header.typ >= ord(low(GDNativeAPIType)).cuint and header.typ <= ord(high(GDNativeAPIType)).cuint: + let typ = GDNativeAPIType(header.typ) + case typ: + of GDNativeCore: + let coreApi = cast[ptr GDNativeCoreAPI1](apiStruct) + if coreApi[].version.major == 1: + assign(gdNativeApi, coreApi[]): + # Color API + colorNewRGBA + colorNewRGB + colorGetR + colorSetR + colorGetG + colorSetG + colorGetB + colorSetB + colorGetA + colorSetA + colorGetH + colorGetS + colorGetV + colorAsString + colorToRGBA32 + colorAsARGB32 + colorGray + colorInverted + colorContrasted + colorLinearInterpolate + colorBlend + colorToHtml + colorOperatorEqual + colorOperatorLess + + # Vector 2 API + vector2New + vector2AsString + vector2Normalized + vector2Length + vector2Angle + vector2LengthSquared + vector2IsNormalized + vector2DistanceTo + vector2DistanceSquaredTo + vector2AngleTo + vector2AngleToPoint + vector2LinearInterpolate + vector2CubicInterpolate + vector2Rotated + vector2Tangent + vector2Floor + vector2Snapped + vector2Aspect + vector2Dot + vector2Slide + vector2Bounce + vector2Reflect + vector2Abs + vector2Clamped + vector2OperatorAdd + vector2OperatorSubtract + vector2OperatorMultiplyVector + vector2OperatorMultiplyScalar + vector2OperatorDivideVector + vector2OperatorDivideScalar + vector2OperatorEqual + vector2OperatorLess + vector2OperatorNeg + + # Quat API + quatNew + quatNewWithAxisAngle + quatGetX + quatSetX + quatGetY + quatSetY + quatGetZ + quatSetZ + quatGetW + quatSetW + quatAsString + quatLength + quatLengthSquared + quatNormalized + quatIsNormalized + quatInverse + quatDot + quatXform + quatSlerp + quatSlerpni + quatCubicSlerp + quatOperatorMultiply + quatOperatorAdd + quatOperatorSubtract + quatOperatorDivide + quatOperatorEqual + quatOperatorNeg + + # PoolByteArray API + poolByteArrayNew + poolByteArrayNewCopy + poolByteArrayNewWithArray + poolByteArrayAppend + poolByteArrayAppendArray + poolByteArrayInsert + poolByteArrayInvert + poolByteArrayPushBack + poolByteArrayRemove + poolByteArrayResize + poolByteArraySet + poolByteArrayGet + poolByteArraySize + poolByteArrayDestroy + + # PoolIntArray API + poolIntArrayNew + poolIntArrayNewCopy + poolIntArrayNewWithArray + poolIntArrayAppend + poolIntArrayAppendArray + poolIntArrayInsert + poolIntArrayInvert + poolIntArrayPushBack + poolIntArrayRemove + poolIntArrayResize + poolIntArraySet + poolIntArrayGet + poolIntArraySize + poolIntArrayDestroy + + # PoolRealArray API + poolRealArrayNew + poolRealArrayNewCopy + poolRealArrayNewWithArray + poolRealArrayAppend + poolRealArrayAppendArray + poolRealArrayInsert + poolRealArrayInvert + poolRealArrayPushBack + poolRealArrayRemove + poolRealArrayResize + poolRealArraySet + poolRealArrayGet + poolRealArraySize + poolRealArrayDestroy + + # PoolStringArray API + poolStringArrayNew + poolStringArrayNewCopy + poolStringArrayNewWithArray + poolStringArrayAppend + poolStringArrayAppendArray + poolStringArrayInsert + poolStringArrayInvert + poolStringArrayPushBack + poolStringArrayRemove + poolStringArrayResize + poolStringArraySet + poolStringArrayGet + poolStringArraySize + poolStringArrayDestroy + + + # PoolVector2 API + poolVector2ArrayNew + poolVector2ArrayNewCopy + poolVector2ArrayNewWithArray + poolVector2ArrayAppend + poolVector2ArrayAppendArray + poolVector2ArrayInsert + poolVector2ArrayInvert + poolVector2ArrayPushBack + poolVector2ArrayRemove + poolVector2ArrayResize + poolVector2ArraySet + poolVector2ArrayGet + poolVector2ArraySize + poolVector2ArrayDestroy + + # PoolVector3 API + poolVector3ArrayNew + poolVector3ArrayNewCopy + poolVector3ArrayNewWithArray + poolVector3ArrayAppend + poolVector3ArrayAppendArray + poolVector3ArrayInsert + poolVector3ArrayInvert + poolVector3ArrayPushBack + poolVector3ArrayRemove + poolVector3ArrayResize + poolVector3ArraySet + poolVector3ArrayGet + poolVector3ArraySize + poolVector3ArrayDestroy + + # PoolColorArray API + poolColorArrayNew + poolColorArrayNewCopy + poolColorArrayNewWithArray + poolColorArrayAppend + poolColorArrayAppendArray + poolColorArrayInsert + poolColorArrayInvert + poolColorArrayPushBack + poolColorArrayRemove + poolColorArrayResize + poolColorArraySet + poolColorArrayGet + poolColorArraySize + poolColorArrayDestroy + + # Array API + arrayNew + arrayNewCopy + arrayNewPoolColorArray + arrayNewPoolVector3Array + arrayNewPoolVector2Array + arrayNewPoolStringArray + arrayNewPoolRealArray + arrayNewPoolIntArray + arrayNewPoolByteArray + arraySet + arrayGet + arrayOperatorIndex + arrayAppend + arrayClear + arrayCount + arrayEmpty + arrayErase + arrayFront + arrayBack + arrayFind + arrayFindLast + arrayHas + arrayHash + arrayInsert + arrayInvert + arrayPopFront + arrayPopBack + arrayPushBack + arrayPushFront + arrayRemove + arrayResize + arrayRFind + arraySize + arraySort + arraySortCustom + arrayDestroy + + # Dictionary API + dictionaryNew + dictionaryNewCopy + dictionaryDestroy + dictionarySize + dictionaryEmpty + dictionaryClear + dictionaryHas + dictionaryHasAll + dictionaryErase + dictionaryHash + dictionaryKeys + dictionaryValues + dictionaryGet + dictionarySet + dictionaryOperatorIndex + dictionaryNext + dictionaryOperatorEqual + dictionaryToJson + + # NodePath API + nodePathNew + nodePathNewCopy + nodePathDestroy + nodePathAsString + nodePathIsAbsolute + nodePathGetNameCount + nodePathGetName + nodePathGetSubnameCount + nodePathGetSubname + nodePathGetProperty + nodePathIsEmpty + nodePathOperatorEqual + + # Plane API + planeNewWithReals + planeNewWithVectors + planeNewWithNormal + planeAsString + planeNormalized + planeCenter + planeGetAnyPoint + planeIsPointOver + planeDistanceTo + planeHasPoint + planeProject + planeIntersect3 + planeIntersectsRay + planeIntersectsSegment + planeOperatorNeg + planeOperatorEqual + planeSetNormal + planeGetNormal + planeGetD + planeSetD + + # Rect2 API + rect2NewWithPositionAndSize + rect2New + rect2AsString + rect2GetArea + rect2Intersects + rect2Encloses + rect2HasNoArea + rect2Clip + rect2Merge + rect2HasPoint + rect2Grow + rect2Expand + rect2OperatorEqual + rect2GetPosition + rect2GetSize + rect2SetPosition + rect2SetSize + + # Rect3 API + rect3New + rect3GetPosition + rect3SetPosition + rect3GetSize + rect3SetSize + rect3AsString + rect3GetArea + rect3HasNoArea + rect3HasNoSurface + rect3Intersects + rect3Encloses + rect3Merge + rect3Intersection + rect3IntersectsPlane + rect3IntersectsSegment + rect3HasPoint + rect3GetSupport + rect3GetLongestAxis + rect3GetLongestAxisIndex + rect3GetLongestAxisSize + rect3GetShortestAxis + rect3GetShortestAxisIndex + rect3GetShortestAxisSize + rect3Expand + rect3Grow + rect3GetEndpoint + rect3OperatorEqual + + # RID API + ridNew + ridGetID + ridNewWithResource + ridOperatorEqual + ridOperatorLess + + # Transform API + transformNewWithAxisOrigin + transformNew + transformGetBasis + transformSetBasis + transformGetOrigin + transformSetOrigin + transformAsString + transformInverse + transformAffineInverse + transformOrthonormalized + transformRotated + transformScaled + transformTranslated + transformLookingAt + transformXformPlane + transformXformInvPlane + transformNewIdentity + transformOperatorEqual + transformOperatorMultiply + transformXformVector3 + transformXformInvVector3 + transformXformRect3 + transformXformInvRect3 + + # Transform2D API + transform2DNew + transform2DNewAxisOrigin + transform2DAsString + transform2DInverse + transform2DAffineInverse + transform2DGetRotation + transform2DGetOrigin + transform2DGetScale + transform2DOrthonormalized + transform2DRotated + transform2DScaled + transform2DTranslated + transform2DXformVector2 + transform2DXformInvVector2 + transform2DBasisXformVector2 + transform2DBasisXformInvVector2 + transform2DInterpolateWith + transform2DOperatorEqual + transform2DOperatorMultiply + transform2DNewIdentity + transform2DXformRect2 + transform2DXformInvRect2 + + # Variant API + variantGetType + variantNewCopy + variantNewNil + variantNewBool + variantNewUInt + variantNewInt + variantNewReal + variantNewString + variantNewVector2 + variantNewRect2 + variantNewVector3 + variantNewTransform2D + + variantNewPlane + variantNewQuat + variantNewRect3 + variantNewBasis + variantNewTransform + variantNewColor + variantNewNodePath + variantNewRID + variantNewObject + variantNewDictionary + variantNewArray + variantNewPoolByteArray + variantNewPoolIntArray + variantNewPoolRealArray + variantNewPoolStringArray + variantNewPoolVector2Array + variantNewPoolVector3Array + variantNewPoolColorArray + variantAsBool + variantAsUInt + variantAsInt + variantAsReal + variantAsString + variantAsVector2 + variantAsRect2 + variantAsVector3 + variantAsTransform2D + variantAsPlane + variantAsQuat + variantAsRect3 + variantAsBasis + variantAsTransform + variantAsColor + variantAsNodePath + variantAsRID + variantAsObject + variantAsDictionary + variantAsArray + variantAsPoolByteArray + variantAsPoolIntArray + variantAsPoolRealArray + variantAsPoolStringArray + variantAsPoolVector2Array + variantAsPoolVector3Array + variantAsPoolColorArray + variantCall + variantHasMethod + variantOperatorEqual + variantOperatorLess + variantHashCompare + variantBooleanize + variantDestroy + + # String API + stringNew + stringNewCopy + stringNewData + stringGetData + stringCStr + stringOperatorEqual + stringOperatorLess + stringOperatorPlus + stringLength + stringDestroy + + # Misc API + objectDestroy + globalGetSingleton + methodBindGetMethod + methodBindPtrCall + methodBindCall + getClassConstructor + + alloc + realloc + free + + printError + printWarning + print + + for i in 0.cuint.. Date: Mon, 20 Nov 2017 06:52:37 +0700 Subject: [PATCH 095/160] Rename Rect3 to AABB to sync with Godot --- docs/index.rst | 2 +- godot.nimble | 2 +- godot/core/aabb.nim | 73 ++++++++++ godot/core/godotcoretypes.nim | 2 +- godot/core/rect3.nim | 73 ---------- godot/core/transforms.nim | 8 +- godot/core/variants.nim | 10 +- godot/gdnativeapi.nim | 192 +++++++++++++------------- godot/godot.nim | 4 +- godot/godotapigen.nim | 2 +- godot/internal/godotinternaltypes.nim | 2 +- godot/internal/godotvariants.nim | 8 +- godot/nim/godotnim.nim | 12 +- 13 files changed, 195 insertions(+), 195 deletions(-) create mode 100644 godot/core/aabb.nim delete mode 100644 godot/core/rect3.nim diff --git a/docs/index.rst b/docs/index.rst index 320e99a..a1607f6 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -152,7 +152,7 @@ exported and you don't have to import any of them directly. * `quats `_ Defines ``Quat`` (quaternion) describing object rotation in 3D space. * `rect2 `_ Defines ``Rect2`` - a 2D rectangle. -* `rect3 `_ Defines ``Rect3`` - a 3D box. +* `aabb `_ Defines ``AABB`` - a 3D box. * `rids `_ Defines ``RID`` - a resource identifier. * `transform2d `_ Defines ``Transform2D``. * `transforms `_ Defines ``Transform``. diff --git a/godot.nimble b/godot.nimble index 1349055..72b93a8 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.4" +version = "0.6.5" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/aabb.nim b/godot/core/aabb.nim new file mode 100644 index 0000000..5892081 --- /dev/null +++ b/godot/core/aabb.nim @@ -0,0 +1,73 @@ +# Copyright (c) 2017 Xored Software, Inc. + +import internal.godotinternaltypes, internal.godotstrings +import godotcoretypes, gdnativeapi + +proc initAABB*(pos, size: Vector3): AABB {.inline.} = + AABB(position: pos, size: size) + +proc `$`*(self: AABB): string {.inline.} = + $getGDNativeAPI().aabbAsString(self) + +proc area*(self: AABB): float32 {.inline.} = + getGDNativeAPI().aabbGetArea(self) + +proc hasNoArea*(self: AABB): bool {.inline.} = + getGDNativeAPI().aabbHasNoArea(self) + +proc hasNoSurface*(self: AABB): bool {.inline.} = + getGDNativeAPI().aabbHasNoSurface(self) + +proc intersects*(self, other: AABB): bool {.inline.} = + getGDNativeAPI().aabbIntersects(self, other) + +proc encloses*(self, other: AABB): bool {.inline.} = + getGDNativeAPI().aabbEncloses(self, other) + +proc merge*(self, other: AABB): AABB {.inline.} = + getGDNativeAPI().aabbMerge(self, other) + +proc intersection*(self, other: AABB): AABB {.inline.} = + getGDNativeAPI().aabbIntersection(self, other) + +proc intersectsPlane*(self: AABB; plane: Plane): bool {.inline.} = + getGDNativeAPI().aabbIntersectsPlane(self, plane) + +proc intersectsSegment*(self: AABB; start, to: Vector3): bool {.inline.} = + getGDNativeAPI().aabbIntersectsSegment(self, start, to) + +proc contains*(self: AABB; point: Vector3): bool {.inline.} = + getGDNativeAPI().aabbHasPoint(self, point) + +proc getSupport*(self: AABB; dir: Vector3): Vector3 {.inline.} = + getGDNativeAPI().aabbGetSupport(self, dir) + +proc getLongestAxis*(self: AABB): Vector3 {.inline.} = + getGDNativeAPI().aabbGetLongestAxis(self) + +proc getLongestAxisIndex*(self: AABB): cint {.inline.} = + getGDNativeAPI().aabbGetLongestAxisIndex(self) + +proc getLongestAxisSize*(self: AABB): float32 {.inline.} = + getGDNativeAPI().aabbGetLongestAxisSize(self) + +proc getShortestAxis*(self: AABB): Vector3 {.inline.} = + getGDNativeAPI().aabbGetShortestAxis(self) + +proc getShortestAxisIndex*(self: AABB): cint {.inline.} = + getGDNativeAPI().aabbGetShortestAxisIndex(self) + +proc getShortestAxisSize*(self: AABB): float32 {.inline.} = + getGDNativeAPI().aabbGetShortestAxisSize(self) + +proc expand*(self: AABB; toPoint: Vector3): AABB {.inline.} = + getGDNativeAPI().aabbExpand(self, toPoint) + +proc grow*(self: AABB; by: float32): AABB {.inline.} = + getGDNativeAPI().aabbGrow(self, by) + +proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} = + getGDNativeAPI().aabbGetEndpoint(self, idx) + +proc `==`*(a, b: AABB): bool {.inline.} = + getGDNativeAPI().aabbOperatorEqual(a, b) diff --git a/godot/core/godotcoretypes.nim b/godot/core/godotcoretypes.nim index 8b92407..cc5da9e 100644 --- a/godot/core/godotcoretypes.nim +++ b/godot/core/godotcoretypes.nim @@ -29,7 +29,7 @@ type z*: float32 w*: float32 - Rect3* {.byref.} = object + AABB* {.byref.} = object position*: Vector3 size*: Vector3 diff --git a/godot/core/rect3.nim b/godot/core/rect3.nim deleted file mode 100644 index dc2f2c2..0000000 --- a/godot/core/rect3.nim +++ /dev/null @@ -1,73 +0,0 @@ -# Copyright (c) 2017 Xored Software, Inc. - -import internal.godotinternaltypes, internal.godotstrings -import godotcoretypes, gdnativeapi - -proc initRect3*(pos, size: Vector3): Rect3 {.inline.} = - Rect3(position: pos, size: size) - -proc `$`*(self: Rect3): string {.inline.} = - $getGDNativeAPI().rect3AsString(self) - -proc area*(self: Rect3): float32 {.inline.} = - getGDNativeAPI().rect3GetArea(self) - -proc hasNoArea*(self: Rect3): bool {.inline.} = - getGDNativeAPI().rect3HasNoArea(self) - -proc hasNoSurface*(self: Rect3): bool {.inline.} = - getGDNativeAPI().rect3HasNoSurface(self) - -proc intersects*(self, other: Rect3): bool {.inline.} = - getGDNativeAPI().rect3Intersects(self, other) - -proc encloses*(self, other: Rect3): bool {.inline.} = - getGDNativeAPI().rect3Encloses(self, other) - -proc merge*(self, other: Rect3): Rect3 {.inline.} = - getGDNativeAPI().rect3Merge(self, other) - -proc intersection*(self, other: Rect3): Rect3 {.inline.} = - getGDNativeAPI().rect3Intersection(self, other) - -proc intersectsPlane*(self: Rect3; plane: Plane): bool {.inline.} = - getGDNativeAPI().rect3IntersectsPlane(self, plane) - -proc intersectsSegment*(self: Rect3; start, to: Vector3): bool {.inline.} = - getGDNativeAPI().rect3IntersectsSegment(self, start, to) - -proc contains*(self: Rect3; point: Vector3): bool {.inline.} = - getGDNativeAPI().rect3HasPoint(self, point) - -proc getSupport*(self: Rect3; dir: Vector3): Vector3 {.inline.} = - getGDNativeAPI().rect3GetSupport(self, dir) - -proc getLongestAxis*(self: Rect3): Vector3 {.inline.} = - getGDNativeAPI().rect3GetLongestAxis(self) - -proc getLongestAxisIndex*(self: Rect3): cint {.inline.} = - getGDNativeAPI().rect3GetLongestAxisIndex(self) - -proc getLongestAxisSize*(self: Rect3): float32 {.inline.} = - getGDNativeAPI().rect3GetLongestAxisSize(self) - -proc getShortestAxis*(self: Rect3): Vector3 {.inline.} = - getGDNativeAPI().rect3GetShortestAxis(self) - -proc getShortestAxisIndex*(self: Rect3): cint {.inline.} = - getGDNativeAPI().rect3GetShortestAxisIndex(self) - -proc getShortestAxisSize*(self: Rect3): float32 {.inline.} = - getGDNativeAPI().rect3GetShortestAxisSize(self) - -proc expand*(self: Rect3; toPoint: Vector3): Rect3 {.inline.} = - getGDNativeAPI().rect3Expand(self, toPoint) - -proc grow*(self: Rect3; by: float32): Rect3 {.inline.} = - getGDNativeAPI().rect3Grow(self, by) - -proc getEndpoint*(self: Rect3; idx: cint): Vector3 {.inline.} = - getGDNativeAPI().rect3GetEndpoint(self, idx) - -proc `==`*(a, b: Rect3): bool {.inline.} = - getGDNativeAPI().rect3OperatorEqual(a, b) diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index f70a1f8..fe43ccb 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -55,11 +55,11 @@ proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = getGDNativeAPI().transformXformInvVector3(self, v) -proc xformRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} = - getGDNativeAPI().transformXformRect3(self, rect) +proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} = + getGDNativeAPI().transformXformAABB(self, rect) -proc xformInvRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} = - getGDNativeAPI().transformXformInvRect3(self, rect) +proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} = + getGDNativeAPI().transformXformInvAABB(self, rect) proc `==`*(self: Transform; b: Transform): bool {.inline.} = getGDNativeAPI().transformOperatorEqual(self, b) diff --git a/godot/core/variants.nim b/godot/core/variants.nim index 2dcc8d8..55284a1 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -80,7 +80,7 @@ proc newVariant*(s: string): Variant {.inline.} = godotStr.deinit() import basis, nodepaths -import planes, quats, rect2, rect3, rids +import planes, quats, rect2, aabb, rids import transforms, transform2d, vector2 import vector3, colors @@ -108,9 +108,9 @@ proc newVariant*(quat: Quat): Variant {.inline.} = new(result, variantFinalizer) initGodotVariant(result.godotVariant, quat) -proc newVariant*(rect3: Rect3): Variant {.inline.} = +proc newVariant*(aabb: AABB): Variant {.inline.} = new(result, variantFinalizer) - initGodotVariant(result.godotVariant, rect3) + initGodotVariant(result.godotVariant, aabb) proc newVariant*(basis: Basis): Variant {.inline.} = new(result, variantFinalizer) @@ -207,8 +207,8 @@ proc asPlane*(self: Variant): Plane = proc asQuat*(self: Variant): Quat = self.godotVariant.asQuat() -proc asRect3*(self: Variant): Rect3 = - self.godotVariant.asRect3() +proc asAABB*(self: Variant): AABB = + self.godotVariant.asAABB() proc asBasis*(self: Variant): Basis = self.godotVariant.asBasis() diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index ee7f6ad..64ea7eb 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -910,65 +910,65 @@ type rect2SetSize: proc (self: var Rect2, size: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - # Rect3 API - rect3New: proc (dest: var Rect3, pos, size: Vector3) + # AABB API + aabbNew: proc (dest: var AABB, pos, size: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetPosition: proc (self: Rect3): Vector3 + aabbGetPosition: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3SetPosition: proc (self: var Rect3, pos: Vector3) + aabbSetPosition: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetSize: proc (self: Rect3): Vector3 + aabbGetSize: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3SetSize: proc (self: var Rect3, pos: Vector3) + aabbSetSize: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3AsString: proc (self: Rect3): GodotString + aabbAsString: proc (self: AABB): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetArea: proc (self: Rect3): float32 + aabbGetArea: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasNoArea: proc (self: Rect3): bool + aabbHasNoArea: proc (self: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasNoSurface: proc (self: Rect3): bool + aabbHasNoSurface: proc (self: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Intersects: proc (self, other: Rect3): bool + aabbIntersects: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Encloses: proc (self, other: Rect3): bool + aabbEncloses: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Merge: proc (self, other: Rect3): Rect3 + aabbMerge: proc (self, other: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Intersection: proc (self, other: Rect3): Rect3 + aabbIntersection: proc (self, other: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3IntersectsPlane: proc (self: Rect3, plane: Plane): bool + aabbIntersectsPlane: proc (self: AABB, plane: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3IntersectsSegment: proc (self: Rect3, vFrom, vTo: Vector3): bool + aabbIntersectsSegment: proc (self: AABB, vFrom, vTo: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasPoint: proc (self: Rect3, point: Vector3): bool + aabbHasPoint: proc (self: AABB, point: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetSupport: proc (self: Rect3, dir: Vector3): Vector3 + aabbGetSupport: proc (self: AABB, dir: Vector3): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxis: proc (self: Rect3): Vector3 + aabbGetLongestAxis: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxisIndex: proc (self: Rect3): cint + aabbGetLongestAxisIndex: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxisSize: proc (self: Rect3): float32 + aabbGetLongestAxisSize: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxis: proc (self: Rect3): Vector3 + aabbGetShortestAxis: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxisIndex: proc (self: Rect3): cint + aabbGetShortestAxisIndex: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxisSize: proc (self: Rect3): float32 + aabbGetShortestAxisSize: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Expand: proc (self: Rect3, toPoint: Vector3): Rect3 + aabbExpand: proc (self: AABB, toPoint: Vector3): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Grow: proc (self: Rect3, by: float32): Rect3 + aabbGrow: proc (self: AABB, by: float32): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetEndpoint: proc (self: Rect3, idx: cint): Vector3 + aabbGetEndpoint: proc (self: AABB, idx: cint): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3OperatorEqual: proc (self, other: Rect3): bool + aabbOperatorEqual: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # RID API @@ -1036,9 +1036,9 @@ type transformXformInvVector3: proc (self: Transform, v: Vector3): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformRect3: proc (self: Transform, v: Rect3): Rect3 + transformXformAABB: proc (self: Transform, v: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvRect3: proc (self: Transform, v: Rect3): Rect3 + transformXformInvAABB: proc (self: Transform, v: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1136,7 +1136,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantNewQuat: proc (dest: var GodotVariant, val: Quat) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewRect3: proc (dest: var GodotVariant, val: Rect3) + variantNewAABB: proc (dest: var GodotVariant, val: AABB) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantNewBasis: proc (dest: var GodotVariant, val: Basis) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1203,7 +1203,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsQuat: proc (self: GodotVariant): Quat {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRect3: proc (self: GodotVariant): Rect3 + variantAsAABB: proc (self: GodotVariant): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsBasis: proc (self: GodotVariant): Basis {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2176,65 +2176,65 @@ type rect2SetSize*: proc (self: var Rect2, size: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - # Rect3 API - rect3New*: proc (dest: var Rect3, pos, size: Vector3) + # AABB API + aabbNew*: proc (dest: var AABB, pos, size: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetPosition*: proc (self: Rect3): Vector3 + aabbGetPosition*: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3SetPosition*: proc (self: var Rect3, pos: Vector3) + aabbSetPosition*: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetSize*: proc (self: Rect3): Vector3 + aabbGetSize*: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3SetSize*: proc (self: var Rect3, pos: Vector3) + aabbSetSize*: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3AsString*: proc (self: Rect3): GodotString + aabbAsString*: proc (self: AABB): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetArea*: proc (self: Rect3): float32 + aabbGetArea*: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasNoArea*: proc (self: Rect3): bool + aabbHasNoArea*: proc (self: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasNoSurface*: proc (self: Rect3): bool + aabbHasNoSurface*: proc (self: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Intersects*: proc (self, other: Rect3): bool + aabbIntersects*: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Encloses*: proc (self, other: Rect3): bool + aabbEncloses*: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Merge*: proc (self, other: Rect3): Rect3 + aabbMerge*: proc (self, other: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Intersection*: proc (self, other: Rect3): Rect3 + aabbIntersection*: proc (self, other: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3IntersectsPlane*: proc (self: Rect3, plane: Plane): bool + aabbIntersectsPlane*: proc (self: AABB, plane: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3IntersectsSegment*: proc (self: Rect3, vFrom, vTo: Vector3): bool + aabbIntersectsSegment*: proc (self: AABB, vFrom, vTo: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3HasPoint*: proc (self: Rect3, point: Vector3): bool + aabbHasPoint*: proc (self: AABB, point: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetSupport*: proc (self: Rect3, dir: Vector3): Vector3 + aabbGetSupport*: proc (self: AABB, dir: Vector3): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxis*: proc (self: Rect3): Vector3 + aabbGetLongestAxis*: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxisIndex*: proc (self: Rect3): cint + aabbGetLongestAxisIndex*: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetLongestAxisSize*: proc (self: Rect3): float32 + aabbGetLongestAxisSize*: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxis*: proc (self: Rect3): Vector3 + aabbGetShortestAxis*: proc (self: AABB): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxisIndex*: proc (self: Rect3): cint + aabbGetShortestAxisIndex*: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetShortestAxisSize*: proc (self: Rect3): float32 + aabbGetShortestAxisSize*: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Expand*: proc (self: Rect3, toPoint: Vector3): Rect3 + aabbExpand*: proc (self: AABB, toPoint: Vector3): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3Grow*: proc (self: Rect3, by: float32): Rect3 + aabbGrow*: proc (self: AABB, by: float32): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3GetEndpoint*: proc (self: Rect3, idx: cint): Vector3 + aabbGetEndpoint*: proc (self: AABB, idx: cint): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect3OperatorEqual*: proc (self, other: Rect3): bool + aabbOperatorEqual*: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # RID API @@ -2302,9 +2302,9 @@ type transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformRect3*: proc (self: Transform, v: Rect3): Rect3 + transformXformAABB*: proc (self: Transform, v: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvRect3*: proc (self: Transform, v: Rect3): Rect3 + transformXformInvAABB*: proc (self: Transform, v: AABB): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2402,7 +2402,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantNewQuat*: proc (dest: var GodotVariant, val: Quat) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantNewRect3*: proc (dest: var GodotVariant, val: Rect3) + variantNewAABB*: proc (dest: var GodotVariant, val: AABB) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantNewBasis*: proc (dest: var GodotVariant, val: Basis) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2469,7 +2469,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsQuat*: proc (self: GodotVariant): Quat {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRect3*: proc (self: GodotVariant): Rect3 + variantAsAABB*: proc (self: GodotVariant): AABB {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsBasis*: proc (self: GodotVariant): Basis {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2953,34 +2953,34 @@ proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = rect2SetPosition rect2SetSize - # Rect3 API - rect3New - rect3GetPosition - rect3SetPosition - rect3GetSize - rect3SetSize - rect3AsString - rect3GetArea - rect3HasNoArea - rect3HasNoSurface - rect3Intersects - rect3Encloses - rect3Merge - rect3Intersection - rect3IntersectsPlane - rect3IntersectsSegment - rect3HasPoint - rect3GetSupport - rect3GetLongestAxis - rect3GetLongestAxisIndex - rect3GetLongestAxisSize - rect3GetShortestAxis - rect3GetShortestAxisIndex - rect3GetShortestAxisSize - rect3Expand - rect3Grow - rect3GetEndpoint - rect3OperatorEqual + # AABB API + aabbNew + aabbGetPosition + aabbSetPosition + aabbGetSize + aabbSetSize + aabbAsString + aabbGetArea + aabbHasNoArea + aabbHasNoSurface + aabbIntersects + aabbEncloses + aabbMerge + aabbIntersection + aabbIntersectsPlane + aabbIntersectsSegment + aabbHasPoint + aabbGetSupport + aabbGetLongestAxis + aabbGetLongestAxisIndex + aabbGetLongestAxisSize + aabbGetShortestAxis + aabbGetShortestAxisIndex + aabbGetShortestAxisSize + aabbExpand + aabbGrow + aabbGetEndpoint + aabbOperatorEqual # RID API ridNew @@ -3011,8 +3011,8 @@ proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = transformOperatorMultiply transformXformVector3 transformXformInvVector3 - transformXformRect3 - transformXformInvRect3 + transformXformAABB + transformXformInvAABB # Transform2D API transform2DNew @@ -3054,7 +3054,7 @@ proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = variantNewPlane variantNewQuat - variantNewRect3 + variantNewAABB variantNewBasis variantNewTransform variantNewColor @@ -3081,7 +3081,7 @@ proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = variantAsTransform2D variantAsPlane variantAsQuat - variantAsRect3 + variantAsAABB variantAsBasis variantAsTransform variantAsColor diff --git a/godot/godot.nim b/godot/godot.nim index bab24f7..d72c4f1 100644 --- a/godot/godot.nim +++ b/godot/godot.nim @@ -4,14 +4,14 @@ import core.godotbase, godotinternal import core.godotcoretypes import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes, core.quats -import core.rect3, core.basis, core.transforms, core.colors, core.nodepaths, +import core.aabb, core.basis, core.transforms, core.colors, core.nodepaths, core.rids import core.dictionaries, core.arrays, core.poolarrays, core.variants import nim.godotmacros, nim.godotnim export godotbase, godotcoretypes, vector2, rect2, vector3, transform2d, planes, - quats, rect3, basis, transforms, colors, nodepaths, rids, dictionaries, + quats, aabb, basis, transforms, colors, nodepaths, rids, dictionaries, arrays, poolarrays, variants export godotmacros, godotnim diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 526a1f8..6d12c64 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -274,7 +274,7 @@ const standardTypes = toSet( ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", - "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform", + "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", "Color", "RID", "NodePath", "Dictionary", "Variant", "Array", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim index 29b0e00..ba661ad 100644 --- a/godot/internal/godotinternaltypes.nim +++ b/godot/internal/godotinternaltypes.nim @@ -45,7 +45,7 @@ type Transform2D, Plane, Quat, ## 10 - Rect3, + AABB, Basis, Transform, ## misc types Color, diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 5e9ebb8..d48e876 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -44,8 +44,8 @@ proc initGodotVariant*(dest: var GodotVariant; plane: Plane) {.inline.} = proc initGodotVariant*(dest: var GodotVariant; quat: Quat) {.inline.} = getGDNativeAPI().variantNewQuat(dest, quat) -proc initGodotVariant*(dest: var GodotVariant; rect3: Rect3) {.inline.} = - getGDNativeAPI().variantNewRect3(dest, rect3) +proc initGodotVariant*(dest: var GodotVariant; aabb: AABB) {.inline.} = + getGDNativeAPI().variantNewAABB(dest, aabb) proc initGodotVariant*(dest: var GodotVariant; basis: Basis) {.inline.} = getGDNativeAPI().variantNewBasis(dest, basis) @@ -138,8 +138,8 @@ proc asPlane*(self: GodotVariant): Plane {.inline.} = proc asQuat*(self: GodotVariant): Quat {.inline.} = getGDNativeAPI().variantAsQuat(self) -proc asRect3*(self: GodotVariant): Rect3 {.inline.} = - getGDNativeAPI().variantAsRect3(self) +proc asAABB*(self: GodotVariant): AABB {.inline.} = + getGDNativeAPI().variantAsAABB(self) proc asBasis*(self: GodotVariant): Basis {.inline.} = getGDNativeAPI().variantAsBasis(self) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 54d8d23..b1c4be5 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -5,7 +5,7 @@ import gdnativeapi import core.godotcoretypes import core.vector2, core.rect2, core.vector3, core.transform2d, - core.planes, core.quats, core.rect3, + core.planes, core.quats, core.aabb, core.basis, core.transforms, core.colors, core.nodepaths, core.rids, core.dictionaries, core.arrays, core.poolarrays, core.variants @@ -57,7 +57,7 @@ type SomeFloat = float32 or float64 or cfloat SomeGodot = bool or Vector2 or Rect2 or Vector3 or - Transform2D or Plane or Quat or Rect3 or + Transform2D or Plane or Quat or AABB or Basis or Transform or Color or NodePath or RID or GodotObject or Dictionary or Array or PoolByteArray or PoolIntArray or PoolRealArray or @@ -497,8 +497,8 @@ proc godotTypeInfo*(T: typedesc[SomeGodotOrNum]): GodotTypeInfo {.inline.} = VariantType.Plane elif T is Quat: VariantType.Quat - elif T is Rect3: - VariantType.Rect3 + elif T is AABB: + VariantType.AABB elif T is Basis: VariantType.Basis elif T is Transform: @@ -614,8 +614,8 @@ proc fromVariant*[T: SomeGodot](self: var T, val: Variant): ConversionResult = self = val.asPlane() elif self is Quat: self = val.asQuat() - elif self is Rect3: - self = val.asRect3() + elif self is AABB: + self = val.asAABB() elif self is Basis: self = val.asBasis() elif self is Transform: From a1c378301a993d533d74f8793e46c15e6fb4414f Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 21 Nov 2017 02:44:32 +0700 Subject: [PATCH 096/160] Update for latest Godot --- godot.nimble | 2 +- godot/gdnativeapi.nim | 29 +++++++++++++++------------ godot/godotinternal.nim | 6 ++---- godot/internal/godotinternaltypes.nim | 11 ++++++++-- godot/internal/godotstrings.nim | 3 --- godot/nim/godotnim.nim | 6 +++--- 6 files changed, 31 insertions(+), 26 deletions(-) diff --git a/godot.nimble b/godot.nimble index 72b93a8..fc2f0b3 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.5" +version = "0.6.6" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 64ea7eb..7283ed7 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -9,10 +9,6 @@ type GDNativeExtPluginScript, GDNativeExtNativeARVR - GDNativeAPIVersion = object - major: cuint - minor: cuint - GDNativeAPIHeader = object typ: cuint version: GDNativeAPIVersion @@ -1271,8 +1267,6 @@ type stringGetData: proc (self: GodotString, dest: cstring, size: var cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorIndex: pointer - stringCStr: proc (self: GodotString): cstring - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorIndexConst: pointer stringUTF16Str: pointer stringOperatorEqual: proc (self, other: GodotString): bool @@ -1450,7 +1444,10 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} getClassConstructor: proc (className: cstring): GodotClassConstructor {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - + registerNativeCallType: proc (callType: cstring, + cb: proc (procHandle: pointer, + args: ptr GodotArray): GodotVariant + {.noconv.}) {.noconv.} alloc: proc (bytes: cint): pointer {.noconv, raises: [], gcsafe, tags: [], locks: 0.} realloc: proc (p: pointer, bytes: cint): pointer @@ -2535,8 +2532,6 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringGetData*: proc (self: GodotString, dest: cstring, size: var cint) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringCStr*: proc (self: GodotString): cstring - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorEqual*: proc (self, other: GodotString): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorLess*: proc (self, other: GodotString): bool @@ -2627,7 +2622,7 @@ var gdNativeAPI: GDNativeAPI proc getGDNativeAPI*(): ptr GDNativeAPI {.inline.} = addr gdNativeAPI -proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = +proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = let header = cast[ptr GDNativeAPIHeader](apiStruct) if header.typ >= ord(low(GDNativeAPIType)).cuint and header.typ <= ord(high(GDNativeAPIType)).cuint: @@ -3110,7 +3105,6 @@ proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = stringNewCopy stringNewData stringGetData - stringCStr stringOperatorEqual stringOperatorLess stringOperatorPlus @@ -3134,7 +3128,11 @@ proc setGDNativeAPI*(apiStruct: pointer) {.inline.} = print for i in 0.cuint.. Date: Wed, 22 Nov 2017 12:28:54 +0700 Subject: [PATCH 097/160] Update for latest Godot --- godot.nimble | 2 +- godot/core/nodepaths.nim | 4 ++-- godot/gdnativeapi.nim | 28 +++++++++++++++++++++++----- godot/internal/godotarrays.nim | 9 +++++++++ godot/internal/godotnodepaths.nim | 4 ++-- 5 files changed, 37 insertions(+), 10 deletions(-) diff --git a/godot.nimble b/godot.nimble index fc2f0b3..3e778fd 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.6" +version = "0.6.7" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index 62e30f8..537d93e 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -51,8 +51,8 @@ proc getSubname*(self: NodePath; idx: int): string {.inline.} = result = $s s.deinit() -proc property*(self: NodePath): string {.inline.} = - var s = self.path.property() +proc getConcatenatedSubnames*(self: NodePath): string {.inline.} = + var s = self.path.getConcatenatedSubnames() result = $s s.deinit() diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 7283ed7..2d6d98b 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -750,6 +750,13 @@ type arraySortCustom: proc (self: var GodotArray, obj: ptr GodotObject, f: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBSearch: proc (self: var GodotArray, val: ptr GodotVariant, + before: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBSearchCustom: proc (self: var GodotArray, val: ptr GodotVariant, + obj: ptr GodotObject, f: GodotString, + before: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} arrayDestroy: proc (self: var GodotArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -816,8 +823,9 @@ type locks: 0.} nodePathGetSubname: proc (self: GodotNodePath, idx: cint): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathGetProperty: proc (self: GodotNodePath): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetConcatenatedSubnames: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} nodePathIsEmpty: proc (self: GodotNodePath): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} nodePathOperatorEqual: proc (self, other: GodotNodePath): bool @@ -2018,6 +2026,13 @@ type arraySortCustom*: proc (self: var GodotArray, obj: ptr GodotObject, f: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBSearch*: proc (self: var GodotArray, val: ptr GodotVariant, + before: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + arrayBSearchCustom*: proc (self: var GodotArray, val: ptr GodotVariant, + obj: ptr GodotObject, f: GodotString, + before: bool) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} arrayDestroy*: proc (self: var GodotArray) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2083,8 +2098,9 @@ type locks: 0.} nodePathGetSubname*: proc (self: GodotNodePath, idx: cint): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - nodePathGetProperty*: proc (self: GodotNodePath): GodotString - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + nodePathGetConcatenatedSubnames*: proc (self: GodotNodePath): GodotString + {.noconv, raises: [], gcsafe, + tags: [], locks: 0.} nodePathIsEmpty*: proc (self: GodotNodePath): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} nodePathOperatorEqual*: proc (self, other: GodotNodePath): bool @@ -2871,6 +2887,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = arraySize arraySort arraySortCustom + arrayBSearch + arrayBSearchCustom arrayDestroy # Dictionary API @@ -2903,7 +2921,7 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = nodePathGetName nodePathGetSubnameCount nodePathGetSubname - nodePathGetProperty + nodePathGetConcatenatedSubnames nodePathIsEmpty nodePathOperatorEqual diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index 676e6cd..607474f 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -126,6 +126,15 @@ proc sortCustom*(self: var GodotArray; obj: ptr GodotObject; funcName: GodotString) {.inline.} = getGDNativeAPI().arraySortCustom(self, obj, funcName) +proc binarySearch*(self: var GodotArray, val: ptr GodotVariant, + before: bool) {.inline.} = + getGDNativeAPI().arrayBSearch(self, val, before) + +proc binarySearchCustom*(self: var GodotArray, val: ptr GodotVariant, + obj: ptr GodotObject, funcName: GodotString, + before: bool) {.inline.} = + getGDNativeAPI().arrayBSearchCustom(self, val, obj, funcName, before) + iterator items*(self: GodotArray): GodotVariant = for i in 0.. Date: Wed, 22 Nov 2017 16:36:39 +0700 Subject: [PATCH 098/160] Update for latest Nim --- docs/index.rst | 2 +- godot.nimble | 2 +- godot/internal/godotarrays.nim | 8 ++++---- godot/internal/godotpoolarrays.nim | 4 ++-- godot/nim/godotmacros.nim | 11 ++++++----- 5 files changed, 14 insertions(+), 13 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index a1607f6..bffe100 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -55,7 +55,7 @@ about compiling Godot can be found in `Godot documentation Installing Nim ------------- -The library requires Nim version 0.17.2 or newer, which you can get here: +The library requires Nim version 0.18.0 or newer, which you can get here: https://nim-lang.org/install.html Make sure you also have ``nimble`` (Nim's package manager) installed. diff --git a/godot.nimble b/godot.nimble index 3e778fd..cac30be 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.7" +version = "0.6.8" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index 607474f..32bcefa 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -136,20 +136,20 @@ proc binarySearchCustom*(self: var GodotArray, val: ptr GodotVariant, getGDNativeAPI().arrayBSearchCustom(self, val, obj, funcName, before) iterator items*(self: GodotArray): GodotVariant = - for i in 0.. Date: Wed, 22 Nov 2017 16:48:37 +0700 Subject: [PATCH 099/160] Repair Travis build --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 3dbd69a..d0b4bfa 100644 --- a/.travis.yml +++ b/.travis.yml @@ -27,7 +27,7 @@ addons: - libxrandr-dev before_install: - - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install scons ; fi + - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then rvm --default use 2.3; brew update; brew install scons ; fi install: - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export GODOT_PLATFORM=osx; else export GODOT_PLATFORM=x11; fi From 0d21c361d00d528e3fb678ae409899ff643ab853 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 28 Nov 2017 12:04:07 +0700 Subject: [PATCH 100/160] Use setStackBottom for methods called from outside --- godot.nimble | 2 +- godot/nim/godotmacros.nim | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index cac30be..968dac3 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.8" +version = "0.6.9" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index ef478f9..682f8ec 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -541,10 +541,17 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = template registerGodotMethod(classNameLit, classNameIdent, methodNameIdent, methodNameLit, minArgs, maxArgs, argTypes, methFuncIdent, hasReturnValue) = + {.emit: """/*TYPESECTION*/ +N_NOINLINE(void, setStackBottom)(void* thestackbottom); +""".} proc methFuncIdent(obj: ptr GodotObject, methodData: pointer, userData: pointer, numArgs: cint, args: var array[MAX_ARG_COUNT, ptr GodotVariant]): GodotVariant {.noconv.} = + var stackBottom {.volatile.}: pointer + {.emit: """ + setStackBottom((void*)(&`stackBottom`)); + """.} let self = cast[classNameIdent](userData) const isStaticCall = methodNameLit == cstring"_ready" or methodNameLit == cstring"_process" or From 8d6972f729603291c9d7b20f0475430ab41e85c7 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 8 Dec 2017 13:21:01 +0700 Subject: [PATCH 101/160] Fix doc generation --- docs/docbuild.nim | 4 ++-- godot/godotapigen.nim | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/docbuild.nim b/docs/docbuild.nim index b48368d..653b685 100644 --- a/docs/docbuild.nim +++ b/docs/docbuild.nim @@ -94,7 +94,7 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) = allNimFiles.add(file) for file in allNimFiles: spawn execOrFail( - "nim doc -o:" & quoted(outName(outDirAbs, file)) & + "nim doc -d:useRealtimeGc -o:" & quoted(outName(outDirAbs, file)) & " --git.url:" & quoted(gitHubUrl) & " --git.commit:" & quoted(gitCommit) & ' ' & quoted(file)) @@ -103,7 +103,7 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) = createDir(godotApiFolder) genApiFiles(godotApiFolder, godotBinAbs) for file in walkDirRec(godotApiFolder, {pcFile, pcDir}, [".nim"]): - spawn execOrFail("nim doc " & quoted(file)) + spawn execOrFail("nim doc -d:useRealtimeGc " & quoted(file)) sync() diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 6d12c64..15fd9fc 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -2,7 +2,7 @@ import streams, json, os, strutils, times, sets, tables import sequtils, algorithm -import compiler / [ast, renderer, idents, astalgo] +import compiler.ast, compiler.renderer, compiler.idents, compiler.astalgo proc ident(ident: string): PNode = result = newNode(nkIdent) From c06792df8d846084a3c99d63ee42c110318b56e9 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 8 Dec 2017 16:07:23 +0700 Subject: [PATCH 102/160] Add vec2(). Closes #12 --- godot/core/vector2.nim | 3 +++ 1 file changed, 3 insertions(+) diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 9eca64d..7cf3ee5 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -3,6 +3,9 @@ import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi +proc vec2*(): Vector2 {.inline.} = + Vector2() + proc vec2*(x, y: float32): Vector2 {.inline.} = Vector2(x: x, y: y) From 50835baca82b8c55c123364ada16696938501598 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 8 Dec 2017 15:44:28 +0700 Subject: [PATCH 103/160] Fix travis --- .travis.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index d0b4bfa..b0b27d4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,6 +49,5 @@ script: - set -e - mkdir godotapi - nim c -d:release -r godot/godotapigen.nim "$GODOT_BIN" godotapi - - nimble install -y - - nim c -d:useRealtimeGc -c godotapi/godotall.nim + - nim c -d:useRealtimeGc --path:godot -c godotapi/godotall.nim - nim c -d:release -r docs/docpublish.nim From 72dd992e6644846c84363af3baab3c4020abdcca Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 8 Dec 2017 21:23:32 +0700 Subject: [PATCH 104/160] Fix docbuild --- docs/docbuild.nim | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/docbuild.nim b/docs/docbuild.nim index 653b685..fb957f5 100644 --- a/docs/docbuild.nim +++ b/docs/docbuild.nim @@ -94,7 +94,8 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) = allNimFiles.add(file) for file in allNimFiles: spawn execOrFail( - "nim doc -d:useRealtimeGc -o:" & quoted(outName(outDirAbs, file)) & + "nim doc -d:useRealtimeGc --path:godot -o:" & + quoted(outName(outDirAbs, file)) & " --git.url:" & quoted(gitHubUrl) & " --git.commit:" & quoted(gitCommit) & ' ' & quoted(file)) @@ -103,7 +104,7 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) = createDir(godotApiFolder) genApiFiles(godotApiFolder, godotBinAbs) for file in walkDirRec(godotApiFolder, {pcFile, pcDir}, [".nim"]): - spawn execOrFail("nim doc -d:useRealtimeGc " & quoted(file)) + spawn execOrFail("nim doc -d:useRealtimeGc --path:godot " & quoted(file)) sync() From 4d19140d7c8d1ae7ba84325d86351472cd87e187 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 18 Dec 2017 13:48:01 +0700 Subject: [PATCH 105/160] Update for latest GDNative API changes --- godot.nimble | 2 +- godot/gdnativeapi.nim | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 968dac3..a059e73 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.9" +version = "0.6.10" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 2d6d98b..c6282ae 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1452,6 +1452,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} getClassConstructor: proc (className: cstring): GodotClassConstructor {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + getGlobalConstants: pointer registerNativeCallType: proc (callType: cstring, cb: proc (procHandle: pointer, args: ptr GodotArray): GodotVariant From e2feb0646889d908dc3a54ff57a285eaa01aa2f8 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 18 Dec 2017 17:22:12 +0700 Subject: [PATCH 106/160] Add indexed property support --- godot.nimble | 2 +- godot/godotapigen.nim | 62 +++++++++++++++++++++++++++++++------------ 2 files changed, 46 insertions(+), 18 deletions(-) diff --git a/godot.nimble b/godot.nimble index a059e73..75c518a 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.10" +version = "0.6.11" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 15fd9fc..6d7eae5 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -259,7 +259,17 @@ proc makeConstSection(constObj: JsonNode): PNode = result.add(def) type - MethodArg = tuple[name, typ: string, defaultVal: JsonNode, isVarargs: bool] + ArgKind = enum + Normal, + VarArgs + Bound + + MethodArg = object + name: string + typ: string + defaultVal: JsonNode + kind: ArgKind + MethodInfo = ref object name: PNode godotName: string @@ -349,6 +359,9 @@ proc makeDefaultValue(arg: MethodArg): PNode = "Cannot build default value from $# ($#)" % [$arg.defaultVal, arg.typ]) +proc boundArgName(idx: int): string = + "godotBoundArg" & $idx + proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], meth: MethodInfo, withImplementation: bool) = var body: PNode @@ -390,12 +403,16 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var argLenNode = newIntLit(0) let argsName = ident("argsToPassToGodot") if meth.args.len > 0: - for arg in meth.args: - if arg.isVarargs: + for idx, arg in meth.args: + if arg.kind == ArgKind.VarArgs: varargsName = arg.name isVarargs = true vars.add(newIdentDefs(ident("callError"), ident("VariantCallError"))) - break + elif arg.kind == ArgKind.Bound: + let argName = boundArgName(idx) + vars.add(newIdentDefs( + ident(argName), newNode(nkEmpty), arg.makeDefaultValue())) + let argsAlloc = newNode(nkCast).addChain( newNode(nkPtrTy).addChain( newNode(nkBracketExpr).addChain( @@ -425,12 +442,13 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], let argConversions = newNode(nkStmtList) for idx, arg in meth.args: - var argName = ident(arg.name) - if arg.isVarargs: + var argName = if arg.kind == ArgKind.Bound: ident(boundArgName(idx)) + else: ident(arg.name) + if arg.kind == ArgKind.VarArgs: argName = newNode(nkBracketExpr).addChain( ident(varargsName), infix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) - let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx) + let argIdx = if arg.kind == ArgKind.VarArgs: ident("idx") else: newIntLit(idx) let isStandardType = arg.typ in standardTypes let isWrappedType = arg.typ in wrapperTypes let convArg = if not varargsName.isNil: @@ -440,7 +458,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], elif arg.typ == "string": newCall("unsafeAddr", ident("argToPassToGodot" & $idx)) else: ident("argToPassToGodot" & $idx) # object - if not isStandardType and arg.isVarargs: + if not isStandardType and arg.kind == ArgKind.VarArgs: raise newException(ValueError, "Non-standard type $# for varargs params of method $# of type $#" % [arg.typ, meth.godotName, meth.typ.godotName]) @@ -458,7 +476,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newNode(nkBracketExpr).addChain(argsName), argIdx), convArg ) - if not arg.isVarargs: + if arg.kind != ArgKind.VarArgs: argConversions.add( argAsgn ) @@ -610,12 +628,16 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], params.add(newIdentDefs(ident("self"), ident(toNimType(meth.typ.name)))) for arg in meth.args: - if arg.isVarargs: - params.add(newIdentDefs(ident(arg.name), - newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) - else: + case arg.kind: + of ArgKind.Normal: let defaultValue = arg.makeDefaultValue() params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue)) + of ArgKind.VarArgs: + params.add(newIdentDefs(ident(arg.name), + newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) + of ArgKind.Bound: + discard + let procDecl = newProc(if not withImplementation: postfix(meth.name, "*") else: meth.name, params, body, procType) @@ -656,8 +678,13 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode, name: setterName, typ: typ, godotName: propertyObj["setter"].str, - args: @[("val", nimType, JsonNode(nil), false)] + args: @[MethodArg(name: "val", typ: nimType)] ) + if "index" in propertyObj and propertyObj["index"] != newJInt(-1): + getterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]), + typ: "int", kind: ArgKind.Bound)] & getterInfo.args + setterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]), + typ: "int", kind: ArgKind.Bound)] & setterInfo.args generateMethod(tree, methodBindRegistry, getterInfo, withImplementation) generateMethod(tree, methodBindRegistry, setterInfo, withImplementation) @@ -694,10 +721,11 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, let typ = toNimType(types, arg["type"].str) let defaultVal = if arg["has_default_value"].bval: arg["default_value"] else: nil - args.add((toNimStyle(arg["name"].str), typ, - defaultVal, false)) + args.add(MethodArg( + name: toNimStyle(arg["name"].str), typ: typ, + defaultVal: defaultVal)) if methodObj["has_varargs"].bval: - args.add(("variantArgs", "Variant", JsonNode(nil), true)) + args.add(MethodArg(name: "variantArgs", typ: "Variant", kind: ArgKind.VarArgs)) let godotName = methodObj["name"].str var nimName = toNimStyle(godotName) From d89073bac8affc5b0d90ea7fe4078442d6aa4d3e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 29 Dec 2017 11:50:56 +0700 Subject: [PATCH 107/160] Do not depend on asyncdispatch Instead, allow to register frame callbacks. --- godot.nimble | 2 +- godot/nim/godotnim.nim | 25 ++++++++++++++++++++----- 2 files changed, 21 insertions(+), 6 deletions(-) diff --git a/godot.nimble b/godot.nimble index 75c518a..b2d68a7 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.11" +version = "0.7.0" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 0eccb6b..5a346c6 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,6 +1,6 @@ # Copyright 2017 Xored Software, Inc. -import tables, typetraits, macros, asyncdispatch +import tables, typetraits, macros import gdnativeapi import core.godotcoretypes import core.vector2, core.rect2, @@ -811,15 +811,30 @@ proc godot_gdnative_terminate(options: ptr GDNativeTerminateOptions) {. deallocHeap(runFinalizers = not options[].inEditor, allowGcAfterwards = false) const nimGcStepLengthUs {.intdefine.} = 2000 + +var idleCallbacks {.threadvar.}: seq[proc () {.closure.}] +idleCallbacks = newSeq[proc () {.closure.}]() + +var isMainThread {.threadvar.}: bool +isMainThread = true + +proc registerFrameCallback*(cb: proc () {.closure.}) = + # Registers a callback to be called on the main thread at the end + # of each frame. + if not isMainThread: + const err = cstring"registerFrameIdleCallback is called from non-main thread. Ignoring." + godotPrintError(err, cstring"registerFrameCallback", + cstring"godotnim.nim", 0) + else: + idleCallbacks.add(cb) + proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = var stackBottom {.volatile.}: pointer {.emit: """ setStackBottom((void*)(&`stackBottom`)); """.} - for _ in 1..10: - if not asyncdispatch.hasPendingOperations(): - break - poll(0) + for cb in idleCallbacks: + cb() GC_step(nimGcStepLengthUs, true, 0) when not defined(release): From 09326f5104bdf6290a9b3f071e69bf650347758e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 11 Jan 2018 16:52:41 +0700 Subject: [PATCH 108/160] Fix Reference leak and improve gdnew performance --- godot.nimble | 2 +- godot/godotapigen.nim | 3 ++- godot/nim/godotnim.nim | 24 +++++++++++++++++++----- 3 files changed, 22 insertions(+), 7 deletions(-) diff --git a/godot.nimble b/godot.nimble index b2d68a7..8415020 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.0" +version = "0.7.1" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 6d7eae5..f8c06e3 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -612,7 +612,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], elif isObjRet: body.add(newNode(nkAsgn).addChain(ident("result"), newCall(newBracketExpr(ident("asNimGodotObject"), - newCall("type", ident("result"))), retValIdent))) + newCall("type", ident("result"))), + retValIdent, ident("false"), ident("true")))) elif isStringRet: body.add(newNode(nkAsgn).addChain(ident("result"), newCall("$", retValIdent))) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 5a346c6..01da5ac 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -140,6 +140,13 @@ proc reference(o: ptr GodotObject): bool {.discardable.} = cstring"reference") referenceMethodBind.ptrCall(o, nil, addr result) +var initRefMethodBind {.threadvar.}: ptr GodotMethodBind +proc initRef(o: ptr GodotObject): bool {.discardable.} = + if isNil(initRefMethodBind): + initRefMethodBind = getMethod(cstring"Reference", + cstring"init_ref") + initRefMethodBind.ptrCall(o, nil, addr result) + proc deinit*(obj: NimGodotObject) = ## Destroy the object. You only need to call this for objects not inherited ## from Reference, where manual lifecycle control is necessary. @@ -240,7 +247,7 @@ proc newNimGodotObject[T: NimGodotObject]( result.godotObject.reference() proc asNimGodotObject*[T: NimGodotObject]( - godotObject: ptr GodotObject, forceNativeObject: bool = false): T = + godotObject: ptr GodotObject, forceNativeObject, noRef: bool = false): T = ## Wraps ``godotObject`` into Nim type ``T``. ## This is used by `godotapigen `_ and should rarely be ## used by anything else. @@ -253,7 +260,8 @@ proc asNimGodotObject*[T: NimGodotObject]( result = nil if result.isNil: result = newNimGodotObject[T]( - godotObject, cstring(godotObject.getClassName()), forceNativeObject) + godotObject, cstring(godotObject.getClassName()), + forceNativeObject or noRef) proc newVariant*(obj: NimGodotObject): Variant {.inline.} = newVariant(obj.godotObject) @@ -377,9 +385,15 @@ proc gdnew*[T: NimGodotObject](): T = ## Instantiates new object of type ``T``. const godotName = asCString(toGodotName(T)) const objInfo = classRegistryStatic[godotName] - result = when objInfo.isNative: - asNimGodotObject[T](getClassConstructor(godotName)()) - else: newOwnObj[T](godotName) + when objInfo.isNative: + let godotObject = getClassConstructor(godotName)() + new(result, nimGodotObjectFinalizer[T]) + result.godotObject = godotObject + when objInfo.isRef: + godotObject.initRef() + result.isRef = true + else: + result = newOwnObj[T](godotName) proc newCallError*(err: VariantCallError): ref CallError = ## Instantiates ``CallError`` from Godot ``err``. From d4ab8a5524b767610e4b87787386af7ada801911 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 12 Jan 2018 23:22:50 +0700 Subject: [PATCH 109/160] Update after recent GDNative API changes --- godot.nimble | 2 +- godot/gdnativeapi.nim | 51 +++++++++++++++++++-------- godot/godotapigen.nim | 26 ++++++++------ godot/internal/godotinternaltypes.nim | 3 ++ godot/internal/godotstrings.nim | 20 ++++------- 5 files changed, 62 insertions(+), 40 deletions(-) diff --git a/godot.nimble b/godot.nimble index 8415020..dd4f14d 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.1" +version = "0.7.2" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index c6282ae..3028b96 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1265,18 +1265,20 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # String API + charStringLength: proc (self: GodotCharString): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + charStringGetData: proc (self: GodotCharString): cstring + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + charStringDestroy: proc (self: var GodotCharString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringNew: proc (dest: var GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringNewCopy: proc (dest: var GodotString, src: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringNewData: proc (dest: var GodotString, contents: cstring, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringNewUTF16Data: pointer - stringGetData: proc (self: GodotString, dest: cstring, size: var cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringNewWithWideString: pointer stringOperatorIndex: pointer stringOperatorIndexConst: pointer - stringUTF16Str: pointer + stringWideStr: pointer stringOperatorEqual: proc (self, other: GodotString): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorLess: proc (self, other: GodotString): bool @@ -1285,6 +1287,9 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringLength: proc (self: GodotString): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringCasecmpTo: pointer + stringNocasecmpTo: pointer + stringNaturalnocasecmpTo: pointer stringBeginsWith: pointer stringBeginsWithCharArray: pointer stringBigrams: pointer @@ -1376,11 +1381,14 @@ type stringErase: pointer stringAscii: pointer stringAsciiExtended: pointer - stringUtf8: pointer + stringUtf8: proc (self: GodotString): GodotCharString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringParseUtf8: pointer stringParseUtf8WithLen: pointer - stringCharsToUtf8: pointer - stringCharsToUtf8WithLen: pointer + stringCharsToUtf8: proc (str: cstring): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringCharsToUtf8WithLen: proc (str: cstring, len: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringHash: pointer stringHash64: pointer stringHashChars: pointer @@ -2541,14 +2549,16 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # String API + charStringLength*: proc (self: GodotCharString): cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + charStringGetData*: proc (self: GodotCharString): cstring + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + charStringDestroy*: proc (self: var GodotCharString) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringNew*: proc (dest: var GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringNewCopy*: proc (dest: var GodotString, src: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringNewData*: proc (dest: var GodotString, contents: cstring, size: cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - stringGetData*: proc (self: GodotString, dest: cstring, size: var cint) - {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorEqual*: proc (self, other: GodotString): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorLess*: proc (self, other: GodotString): bool @@ -2559,6 +2569,12 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringDestroy*: proc (self: var GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringUtf8*: proc (self: GodotString): GodotCharString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringCharsToUtf8*: proc (str: cstring): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringCharsToUtf8WithLen*: proc (str: cstring, len: cint): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # Misc API objectDestroy*: proc (self: ptr GodotObject) @@ -3120,15 +3136,20 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = variantDestroy # String API + charStringLength + charStringGetData + charStringDestroy + stringNew stringNewCopy - stringNewData - stringGetData stringOperatorEqual stringOperatorLess stringOperatorPlus stringLength stringDestroy + stringUtf8 + stringCharsToUtf8 + stringCharsToUtf8WithLen # Misc API objectDestroy diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index f8c06e3..4075229 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -697,10 +697,14 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, toNimType(types, methodObj["return_type"].str) else: nil - for prop in typ.jsonNode["properties"]: - if prop["getter"].str == methodObj["name"].str or - prop["setter"].str == methodObj["name"].str: - return + if not typ.isSingleton: + # for singletons we don't generate Nim setters/getters, + # but use plain procedures instead. That's because setter syntax is + # supposed to be used on an object (have at least 2 params). + for prop in typ.jsonNode["properties"]: + if prop["getter"].str == methodObj["name"].str or + prop["setter"].str == methodObj["name"].str: + return var args = newSeqOfCap[MethodArg](methodObj["arguments"].len + 1) var origArgs = methodObj["arguments"] @@ -924,16 +928,18 @@ proc genApi*(targetDir: string, apiJsonFile: string) = # first, generate declarations only for ease of # human readability of the file - for property in obj["properties"]: - makeProperty(types, tree, methodBindRegsitry, typ, property, - withImplementation = false) + if not typ.isSingleton: + for property in obj["properties"]: + makeProperty(types, tree, methodBindRegsitry, typ, property, + withImplementation = false) for meth in obj["methods"]: makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = false) - for property in obj["properties"]: - makeProperty(types, tree, methodBindRegsitry, typ, - property, withImplementation = true) + if not typ.isSingleton: + for property in obj["properties"]: + makeProperty(types, tree, methodBindRegsitry, typ, + property, withImplementation = true) for meth in obj["methods"]: makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = true) diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim index 508c39e..2ae38c3 100644 --- a/godot/internal/godotinternaltypes.nim +++ b/godot/internal/godotinternaltypes.nim @@ -32,6 +32,9 @@ type GodotString* {.byref.} = object data: array[sizeof(int), byte] + GodotCharString* {.byref.} = object + data: array[sizeof(int), byte] + VariantType* {.size: sizeof(cint), pure.} = enum Nil, ## atomic types Bool, diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index 58e4a24..fce9a41 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -8,16 +8,7 @@ proc initGodotString(dest: var GodotString) {.inline, raises: [].} = proc initGodotString(dest: var GodotString; contents: cstring; size: cint) {.inline.} = ## Initializes ``dest`` from UTF-8 ``contents`` - getGDNativeAPI().stringNewData(dest, contents, size) - -proc getData(self: GodotString; dest: cstring; - size: var cint) {.inline.} = - ## Converts ``self`` into UTF-8 encoding, putting the result into ``dest``. - getGDNativeAPI().stringGetData(self, dest, size) - -proc len*(self: GodotString): cint {.inline.} = - ## Returns the length of string in bytes if it is represented as UTF-8. - getData(self, nil, result) + dest = getGDNativeAPI().stringCharsToUtf8WithLen(contents, size) proc `==`*(self, b: GodotString): bool {.inline.} = getGDNativeAPI().stringOperatorEqual(self, b) @@ -33,10 +24,11 @@ proc deinit*(self: var GodotString) {.inline.} = proc `$`*(self: GodotString): string = ## Converts the ``GodotString`` into Nim string - var length = self.len - result = newStringOfCap(length) - getData(self, addr result[0], length) - result.setLen(length) + var charStr = getGDNativeAPI().stringUtf8(self) + let length = getGDNativeAPI().charStringLength(charStr) + result = newString(length) + copyMem(addr result[0], getGDNativeAPI().charStringGetData(charStr), length) + getGDNativeAPI().charStringDestroy(charStr) assert(result[length] == '\0') proc toGodotString*(s: string): GodotString {.inline.} = From ae3171cb98a1bf9e005615c0ced636590af4dc9b Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 15 Jan 2018 11:01:48 +0700 Subject: [PATCH 110/160] Fix Vector2 += --- godot.nimble | 2 +- godot/core/vector2.nim | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index dd4f14d..3cdedab 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.2" +version = "0.7.3" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 7cf3ee5..86c8a7e 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -83,7 +83,7 @@ proc `+`*(self, other: Vector2): Vector2 {.inline.} = getGDNativeAPI().vector2OperatorAdd(self, other) proc `+=`*(self: var Vector2, other: Vector2) {.inline.} = - self += other + self = self + other proc `-`*(self, other: Vector2): Vector2 = getGDNativeAPI().vector2OperatorSubtract(self, other) From e3216f09d00f11e18194db7afa5b410ae002552f Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 25 Jan 2018 17:39:01 +0700 Subject: [PATCH 111/160] Update ref types not to be var in parameters --- godot/core/arrays.nim | 26 +++++++++++++------------- godot/core/dictionaries.nim | 6 +++--- godot/core/poolarrays.nim | 20 ++++++++++---------- 3 files changed, 26 insertions(+), 26 deletions(-) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 414ac99..a2b4580 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -62,16 +62,16 @@ proc newArray*(pba: PoolByteArray): Array {.inline.} = new(result, arrayFinalizer) initGodotArray(result.godotArray, pba.godotPoolByteArray[]) -proc `[]=`*(self: var Array; idx: int; value: Variant) {.inline.} = +proc `[]=`*(self: Array; idx: int; value: Variant) {.inline.} = self.godotArray[idx.cint] = value.godotVariant[] proc `[]`*(self: Array; idx: int): Variant {.inline.} = newVariant(self.godotArray[idx.cint]) -proc add*(self: var Array; value: Variant) {.inline.} = +proc add*(self: Array; value: Variant) {.inline.} = self.godotArray.add(value.godotVariant[]) -proc clear*(self: var Array) {.inline.} = +proc clear*(self: Array) {.inline.} = self.godotArray.clear() proc count*(self: Array; value: Variant): int {.inline.} = @@ -80,7 +80,7 @@ proc count*(self: Array; value: Variant): int {.inline.} = proc isEmpty*(self: Array): bool {.inline.} = self.godotArray.isEmpty() -proc erase*(self: var Array; value: Variant) {.inline.} = +proc erase*(self: Array; value: Variant) {.inline.} = self.godotArray.erase(value.godotVariant[]) proc first*(self: Array): Variant {.inline.} = @@ -101,28 +101,28 @@ proc contains*(self: Array; value: Variant): bool {.inline.} = proc hash*(self: Array): Hash {.inline.} = hash(self.godotArray.godotHash()) -proc insert*(self: var Array; pos: int; value: Variant) {.inline.} = +proc insert*(self: Array; pos: int; value: Variant) {.inline.} = self.godotArray.insert(pos.cint, value.godotVariant[]) -proc reverse*(self: var Array) {.inline.} = +proc reverse*(self: Array) {.inline.} = self.godotArray.reverse() -proc popLast*(self: var Array): Variant {.inline.} = +proc popLast*(self: Array): Variant {.inline.} = newVariant(self.godotArray.popLast()) -proc popFirst*(self: var Array): Variant {.inline.} = +proc popFirst*(self: Array): Variant {.inline.} = newVariant(self.godotArray.popFirst()) -proc addLast*(self: var Array; value: Variant) {.inline.} = +proc addLast*(self: Array; value: Variant) {.inline.} = self.godotArray.addLast(value.godotVariant[]) -proc addFirst*(self: var Array; value: Variant) {.inline.} = +proc addFirst*(self: Array; value: Variant) {.inline.} = self.godotArray.addFirst(value.godotVariant[]) -proc delete*(self: var Array; idx: int) {.inline.} = +proc delete*(self: Array; idx: int) {.inline.} = self.godotArray.delete(idx.cint) -proc setLen*(self: var Array; size: int) {.inline.} = +proc setLen*(self: Array; size: int) {.inline.} = self.godotArray.setLen(size.cint) proc rfind*(self: Array; what: Variant; fromIdx: int): int {.inline.} = @@ -131,7 +131,7 @@ proc rfind*(self: Array; what: Variant; fromIdx: int): int {.inline.} = proc len*(self: Array): int {.inline.} = self.godotArray.len.int -proc sort*(self: var Array) {.inline.} = +proc sort*(self: Array) {.inline.} = self.godotArray.sort() iterator items*(self: Array): Variant = diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 5445d27..9897814 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -30,7 +30,7 @@ proc len*(self: Dictionary): int {.inline.} = proc isEmpty*(self: Dictionary): bool {.inline.} = self.godotDictionary.isEmpty() -proc clear*(self: var Dictionary) {.inline.} = +proc clear*(self: Dictionary) {.inline.} = self.godotDictionary.clear() import variants, arrays @@ -48,7 +48,7 @@ proc contains*(self: Dictionary; key: Variant): bool {.inline.}= proc contains*(self: Dictionary; keys: Array): bool {.inline.} = self.godotDictionary.contains(keys.godotArray[]) -proc del*(self: var Dictionary; key: Variant) {.inline.} = +proc del*(self: Dictionary; key: Variant) {.inline.} = self.godotDictionary.del(key.godotVariant[]) proc hash*(self: Dictionary): Hash {.inline.} = @@ -71,7 +71,7 @@ proc `[]`*(self: Dictionary; keyStr: string): Variant {.inline.} = godotStr.deinit() godotVariant.deinit() -proc `[]=`*(self: var Dictionary; key, value: Variant) {.inline.} = +proc `[]=`*(self: Dictionary; key, value: Variant) {.inline.} = self.godotDictionary[key.godotVariant[]] = value.godotVariant[] proc `==`*(self, other: Dictionary): bool {.inline.} = diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index dd3f544..6d412f5 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -33,29 +33,29 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; new(result, poolArrayFinalizer) initProcName(result.fieldName, arr.godotArray[]) - proc add*(self: var T; arr: T) {.inline.} = + proc add*(self: T; arr: T) {.inline.} = self.fieldName.add(arr.fieldName) - proc delete*(self: var T; idx: int) {.inline.} = + proc delete*(self: T; idx: int) {.inline.} = self.fieldName.delete(idx.cint) - proc reverse*(self: var T) {.inline.} = + proc reverse*(self: T) {.inline.} = self.fieldName.reverse() - proc setLen*(self: var T; size: int) {.inline.} = + proc setLen*(self: T; size: int) {.inline.} = self.fieldName.setLen(size.cint) proc len*(self: T): int {.inline.} = self.fieldName.len.int when not noData: - proc add*(self: var T; data: DataT) {.inline.} = + proc add*(self: T; data: DataT) {.inline.} = self.fieldName.add(data) - proc insert*(self: var T; idx: int; data: DataT): Error {.inline.} = + proc insert*(self: T; idx: int; data: DataT): Error {.inline.} = self.fieldName.insert(idx.cint, data) - proc `[]=`*(self: var T; idx: int; data: DataT) {.inline.} = + proc `[]=`*(self: T; idx: int; data: DataT) {.inline.} = self.fieldName[idx.cint] = data proc `[]`*(self: T; idx: int): DataT {.inline.} = @@ -115,17 +115,17 @@ definePoolArray(PoolStringArray, GodotPoolStringArray, string, godotPoolStringArray, newPoolStringArray, initGodotPoolStringArray, true) -proc add*(self: var PoolStringArray; data: string) = +proc add*(self: PoolStringArray; data: string) = var s = data.toGodotString() self.godotPoolStringArray.add(s) s.deinit() -proc insert*(self: var PoolStringArray; idx: int; data: string): Error = +proc insert*(self: PoolStringArray; idx: int; data: string): Error = var s = data.toGodotString() result = self.godotPoolStringArray.insert(idx.cint, s) s.deinit() -proc `[]=`*(self: var PoolStringArray; idx: int; data: string) = +proc `[]=`*(self: PoolStringArray; idx: int; data: string) = var s = data.toGodotString() self.godotPoolStringArray[idx.cint] = s s.deinit() From f05eb090f710df4aed71e6502da8258c5abbb6d9 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 25 Jan 2018 17:52:58 +0700 Subject: [PATCH 112/160] Update after GDNative API changes --- godot.nimble | 2 +- godot/gdnativeapi.nim | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 3cdedab..7cd8c26 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.3" +version = "0.7.4" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 3028b96..53aba0e 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -624,46 +624,60 @@ type # Pool Array Read Access API + poolByteArrayReadAccessCopy: pointer poolByteArrayReadAccessPtr: pointer poolByteArrayReadAccessOperatorAssign: pointer poolByteArrayReadAccessDestroy: pointer + poolIntArrayReadAccessCopy: pointer poolIntArrayReadAccessPtr: pointer poolIntArrayReadAccessOperatorAssign: pointer poolIntArrayReadAccessDestroy: pointer + poolRealArrayReadAccessCopy: pointer poolRealArrayReadAccessPtr: pointer poolRealArrayReadAccessOperatorAssign: pointer poolRealArrayReadAccessDestroy: pointer + poolStringArrayReadAccessCopy: pointer poolStringArrayReadAccessPtr: pointer poolStringArrayReadAccessOperatorAssign: pointer poolStringArrayReadAccessDestroy: pointer + poolVector2ArrayReadAccessCopy: pointer poolVector2ArrayReadAccessPtr: pointer poolVector2ArrayReadAccessOperatorAssign: pointer poolVector2ArrayReadAccessDestroy: pointer + poolVector3ArrayReadAccessCopy: pointer poolVector3ArrayReadAccessPtr: pointer poolVector3ArrayReadAccessOperatorAssign: pointer poolVector3ArrayReadAccessDestroy: pointer + poolColorArrayReadAccessCopy: pointer poolColorArrayReadAccessPtr: pointer poolColorArrayReadAccessOperatorAssign: pointer poolColorArrayReadAccessDestroy: pointer + poolByteArrayWriteAccessCopy: pointer poolByteArrayWriteAccessPtr: pointer poolByteArrayWriteAccessOperatorAssign: pointer poolByteArrayWriteAccessDestroy: pointer + poolIntArrayWriteAccessCopy: pointer poolIntArrayWriteAccessPtr: pointer poolIntArrayWriteAccessOperatorAssign: pointer poolIntArrayWriteAccessDestroy: pointer + poolRealArrayWriteAccessCopy: pointer poolRealArrayWriteAccessPtr: pointer poolRealArrayWriteAccessOperatorAssign: pointer poolRealArrayWriteAccessDestroy: pointer + poolStringArrayWriteAccessCopy: pointer poolStringArrayWriteAccessPtr: pointer poolStringArrayWriteAccessOperatorAssign: pointer poolStringArrayWriteAccessDestroy: pointer + poolVector2ArrayWriteAccessCopy: pointer poolVector2ArrayWriteAccessPtr: pointer poolVector2ArrayWriteAccessOperatorAssign: pointer poolVector2ArrayWriteAccessDestroy: pointer + poolVector3ArrayWriteAccessCopy: pointer poolVector3ArrayWriteAccessPtr: pointer poolVector3ArrayWriteAccessOperatorAssign: pointer poolVector3ArrayWriteAccessDestroy: pointer + poolColorArrayWriteAccessCopy: pointer poolColorArrayWriteAccessPtr: pointer poolColorArrayWriteAccessOperatorAssign: pointer poolColorArrayWriteAccessDestroy: pointer From 5ccf351b5a49b148a24be0c971d63edecc03a905 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 31 Jan 2018 20:30:13 +0700 Subject: [PATCH 113/160] Fix Variant export --- godot/nim/godotnim.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 01da5ac..f9da831 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -483,7 +483,7 @@ proc toVariant*(self: Variant): Variant {.inline.} = if self.isNil: newVariant() else: - self + newVariant(self) proc fromVariant*(self: var Variant, val: Variant): ConversionResult {.inline.} = From 0aab6e17efd99253912889a222c7878ba3208e4c Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 31 Jan 2018 20:52:15 +0700 Subject: [PATCH 114/160] Update license year and fix doc to have Godot 3.0 download URL --- .vscode/settings.json | 2 +- LICENSE | 2 +- README.md | 2 +- docs/docbuild.nim | 2 +- docs/docpublish.nim | 2 +- docs/index.rst | 25 ++++++------------------- godot.nimble | 2 +- godot/core/aabb.nim | 2 +- godot/core/arrays.nim | 2 +- godot/core/basis.nim | 2 +- godot/core/colors.nim | 2 +- godot/core/dictionaries.nim | 2 +- godot/core/godotbase.nim | 2 +- godot/core/godotcoretypes.nim | 2 +- godot/core/nodepaths.nim | 2 +- godot/core/planes.nim | 2 +- godot/core/poolarrays.nim | 2 +- godot/core/quats.nim | 2 +- godot/core/rect2.nim | 2 +- godot/core/rids.nim | 2 +- godot/core/transform2d.nim | 2 +- godot/core/transforms.nim | 2 +- godot/core/vector2.nim | 2 +- godot/core/vector3.nim | 2 +- godot/gdnativeapi.nim | 2 +- godot/godot.nim | 2 +- godot/godotapigen.nim | 2 +- godot/godotinternal.nim | 2 +- godot/internal/godotarrays.nim | 2 +- godot/internal/godotdictionaries.nim | 2 +- godot/internal/godotinternaltypes.nim | 2 +- godot/internal/godotnodepaths.nim | 2 +- godot/internal/godotpoolarrays.nim | 2 +- godot/internal/godotstrings.nim | 2 +- godot/internal/godotvariants.nim | 2 +- godot/nim/godotmacros.nim | 2 +- godot/nim/godotnim.nim | 2 +- 37 files changed, 42 insertions(+), 55 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index aa6f1c7..6960f9a 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,7 +9,7 @@ "godot/godotapigen.nim"], "nim.buildOnSave": false, "nim.lintOnSave": true, - "nim.licenseString": "# Copyright 2017 Xored Software, Inc.\n\n", + "nim.licenseString": "# Copyright 2018 Xored Software, Inc.\n\n", "files.exclude": { "**/nimcache/**": true } diff --git a/LICENSE b/LICENSE index 16a448a..07ecdb6 100644 --- a/LICENSE +++ b/LICENSE @@ -2,7 +2,7 @@ godot-nim - Nim bindings for Godot Engine The MIT License -Copyright (c) 2017 Xored Software Inc. +Copyright (c) 2018 Xored Software Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, diff --git a/README.md b/README.md index 7c518a2..891a920 100644 --- a/README.md +++ b/README.md @@ -13,4 +13,4 @@ Documentation: https://pragmagic.github.io/godot-nim/ This project is licensed under the MIT license. Read [LICENSE](LICENSE) file for details. -Copyright (c) 2017 Xored Software, Inc. \ No newline at end of file +Copyright (c) 2018 Xored Software, Inc. \ No newline at end of file diff --git a/docs/docbuild.nim b/docs/docbuild.nim index fb957f5..bb3e21c 100644 --- a/docs/docbuild.nim +++ b/docs/docbuild.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import threadpool, os, osproc, strutils, sequtils, pegs diff --git a/docs/docpublish.nim b/docs/docpublish.nim index d682aec..e55974c 100644 --- a/docs/docpublish.nim +++ b/docs/docpublish.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import os, pegs, strutils import docbuild diff --git a/docs/index.rst b/docs/index.rst index bffe100..e14d38d 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -5,6 +5,7 @@ Nim bindings for Godot Engine :Author: Ruslan Mustakov :Version: |godotnimversion| :GitHub: `$GODOTNIM_GITHUB_URL <$GODOTNIM_GITHUB_URL>`_ +:License: MIT .. contents:: @@ -32,25 +33,11 @@ which adds features for editing GDScript and Godot resource files. Getting Started =============== -Building Godot +Getting Godot -------------- -The library requires a not yet released Godot version 3.0, which you can -build yourself by running the commands below (requires -`Git `_, -`Python 2.7 `_, -`SCons `_): - -.. code-block:: bash - git clone https://github.com/godotengine/godot.git - cd godot - scons platform= - -where ```` can be ``windows``, ``osx``, ``x11``. After build -is finished, Godot binaries will be under the ``bin`` folder. More details -about compiling Godot can be found in `Godot documentation -`_. - +The library requires Godot version 3.0, which you can get here: +https://godotengine.org/download Installing Nim ------------- @@ -63,7 +50,7 @@ Make sure you also have ``nimble`` (Nim's package manager) installed. Creating Project ---------------- -The fastest way to set up a Godot-Nim project is to use an existing stub: +The fastest way to set up a Godot-Nim project is to use the existing stub: .. code-block:: bash git clone --depth=1 https://github.com/pragmagic/godot-nim-stub.git myproject @@ -88,7 +75,7 @@ If you would like to use Nim in an existing project: build scripts (``nakefile.nim``, ``src/stub.nimble``) according to your own project structure. -2. Copy ``project/nimlib.tres`` to your Godot project folder. It is a +2. Copy ``nimlib.gdnlib`` to your Godot project folder. It is a GDNative library resource that contains paths to dynamic libraries compiled by Nim. diff --git a/godot.nimble b/godot.nimble index 7cd8c26..ba9987f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.4" +version = "0.7.5" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/aabb.nim b/godot/core/aabb.nim index 5892081..88bf66a 100644 --- a/godot/core/aabb.nim +++ b/godot/core/aabb.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index a2b4580..afe8131 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import hashes import internal.godotinternaltypes, internal.godotarrays diff --git a/godot/core/basis.nim b/godot/core/basis.nim index 6f7e9d9..1d4f33c 100644 --- a/godot/core/basis.nim +++ b/godot/core/basis.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import math import godotbase, vector3, quats diff --git a/godot/core/colors.nim b/godot/core/colors.nim index dedb1a2..46fcaf3 100644 --- a/godot/core/colors.nim +++ b/godot/core/colors.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import godotcoretypes, gdnativeapi diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 9897814..85970e5 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import hashes import internal.godotinternaltypes, internal.godotdictionaries, diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index 0f410b8..7871a87 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import math diff --git a/godot/core/godotcoretypes.nim b/godot/core/godotcoretypes.nim index cc5da9e..c4c4b71 100644 --- a/godot/core/godotcoretypes.nim +++ b/godot/core/godotcoretypes.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. type Color* {.byref.} = object diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index 537d93e..428e261 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotnodepaths, internal.godotstrings diff --git a/godot/core/planes.nim b/godot/core/planes.nim index 99dd652..66de34e 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import vector3 diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 6d412f5..55ce845 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import godotcoretypes import internal.godotinternaltypes, internal.godotpoolarrays, diff --git a/godot/core/quats.nim b/godot/core/quats.nim index ea8cad4..a60efc8 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi diff --git a/godot/core/rect2.nim b/godot/core/rect2.nim index ad813a9..6e7c99e 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import vector2 import internal.godotinternaltypes, internal.godotstrings diff --git a/godot/core/rids.nim b/godot/core/rids.nim index a113f60..35e054a 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import godotcoretypes, internal.godotinternaltypes, gdnativeapi diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index 922b24b..6fa4619 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index fe43ccb..c9021d6 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 86c8a7e..b665dbd 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi diff --git a/godot/core/vector3.nim b/godot/core/vector3.nim index ded30ce..f90bcfa 100644 --- a/godot/core/vector3.nim +++ b/godot/core/vector3.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import math import godotbase, godotcoretypes diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 53aba0e..0037b8a 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import internal.godotinternaltypes, core.godotcoretypes, macros diff --git a/godot/godot.nim b/godot/godot.nim index d72c4f1..f4a9bf8 100644 --- a/godot/godot.nim +++ b/godot/godot.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import core.godotbase, godotinternal import core.godotcoretypes diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 4075229..c3c07cd 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import streams, json, os, strutils, times, sets, tables import sequtils, algorithm diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index 90903a7..0314624 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import internal.godotinternaltypes, internal.godotarrays, internal.godotnodepaths, internal.godotpoolarrays, internal.godotstrings, diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index 32bcefa..c0736b5 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import godotinternaltypes, gdnativeapi, core.godotcoretypes diff --git a/godot/internal/godotdictionaries.nim b/godot/internal/godotdictionaries.nim index 7c61b76..447647a 100644 --- a/godot/internal/godotdictionaries.nim +++ b/godot/internal/godotdictionaries.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import godotinternaltypes, gdnativeapi diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim index 2ae38c3..cfba553 100644 --- a/godot/internal/godotinternaltypes.nim +++ b/godot/internal/godotinternaltypes.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. const MAX_ARG_COUNT* = 256 diff --git a/godot/internal/godotnodepaths.nim b/godot/internal/godotnodepaths.nim index 11a0280..b4578c0 100644 --- a/godot/internal/godotnodepaths.nim +++ b/godot/internal/godotnodepaths.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import godotinternaltypes, gdnativeapi diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index e655adb..52b1f3a 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import godotinternaltypes, gdnativeapi import core.godotcoretypes diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index fce9a41..d3eb287 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -1,4 +1,4 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. import godotinternaltypes, gdnativeapi diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index d48e876..3f961ca 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import core.godotcoretypes, godotinternaltypes, gdnativeapi diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 682f8ec..384aa2b 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import macros, tables, typetraits import godotinternal, internal.godotvariants diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index f9da831..b989bda 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,4 +1,4 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import tables, typetraits, macros import gdnativeapi From d11856377e05212663c72dd06947f9e40456cff3 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 17 Feb 2018 23:44:07 +0700 Subject: [PATCH 115/160] Implement Vector2 and Rect2 procs This allows compiler to inline/optimize them, which cannot be done if these procs are invoked via GDNative API. --- godot.nimble | 2 +- godot/core/basis.nim | 4 + godot/core/godotbase.nim | 45 ++++++- godot/core/rect2.nim | 148 +++++++++++++++++---- godot/core/vector2.nim | 270 +++++++++++++++++++++++++-------------- godot/core/vector3.nim | 4 + godot/nim/godotnim.nim | 21 +-- 7 files changed, 346 insertions(+), 148 deletions(-) diff --git a/godot.nimble b/godot.nimble index ba9987f..e562fca 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.5" +version = "0.7.6" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/basis.nim b/godot/core/basis.nim index 1d4f33c..538ca60 100644 --- a/godot/core/basis.nim +++ b/godot/core/basis.nim @@ -4,6 +4,8 @@ import math import godotbase, vector3, quats import godotcoretypes +{.push stackTrace: off.} + proc setCells*(basis: var Basis, xx, xy, xz, yx, yy, yz, zx, zy, zz: float32) = basis.elements[0].x = xx basis.elements[0].y = xy @@ -449,3 +451,5 @@ proc rotate*(self: var Vector3; axis: Vector3; phi: float32) = proc rotated*(self: Vector3; axis: Vector3; phi: float32): Vector3 = result = self result.rotate(axis, phi) + +{.pop.} # stackTrace: off \ No newline at end of file diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index 7871a87..38cca0f 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -1,30 +1,61 @@ # Copyright (c) 2018 Xored Software, Inc. -import math +import math, godotinternal # math helpers +{.push stackTrace: off.} const EPSILON = 0.00001'f32 -proc isEqualApprox*(a, b: float32): bool {.inline.} = +proc isEqualApprox*(a, b: float32): bool {.inline, noinit.} = abs(a - b) < EPSILON -proc isEqualApprox*(a, b: float64): bool {.inline.} = +proc isEqualApprox*(a, b: float64): bool {.inline, noinit.} = abs(a - b) < EPSILON -proc sign*(a: float32): float32 {.inline.} = +proc sign*(a: float32): float32 {.inline, noinit.} = if a < 0: -1.0'f32 else: 1.0'f32 -proc sign*(a: float64): float64 {.inline.} = +proc sign*(a: float64): float64 {.inline, noinit.} = if a < 0: -1.0'f64 else: 1.0'f64 -proc stepify*(value, step: float64): float64 = +proc stepify*(value, step: float64): float64 {.inline, noinit.} = if step != 0'f64: floor(value / step + 0.5'f64) * step else: value -proc stepify*(value, step: float32): float32 = +proc stepify*(value, step: float32): float32 {.inline, noinit.} = if step != 0'f32: floor(value / step + 0.5'f32) * step else: value + +proc min*(x, y: float32): float32 {.inline, noinit.} = + if x <= y: x else: y + +proc abs*(x: float32): float32 {.inline, noinit.} = + if x < 0.0: -x else: x + +proc max*(x, y: float32): float32 {.inline, noinit.} = + if y <= x: x else: y + +{.pop.} # stackTrace: off + +template printWarning*(warning: typed) = + ## Prints ``warning`` to Godot log, adding filename and line information. + let (filename, line) = instantiationInfo() + godotPrintWarning(cstring($warning), cstring"", cstring(filename), line.cint) + +template printError*(error: typed) = + ## Prints ``error`` to Godot log, adding filename and line information. + let (filename, line) = instantiationInfo() + godotPrintError(cstring($error), cstring"", cstring(filename), line.cint) + +proc print*(parts: varargs[string, `$`]) = + ## Prints concatenated ``parts`` to Godot log. + var combined = "" + for v in parts: + combined.add(v) + var s = combined.toGodotString() + godotPrint(s) + s.deinit() diff --git a/godot/core/rect2.nim b/godot/core/rect2.nim index 6e7c99e..2e73571 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -4,41 +4,145 @@ import vector2 import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi -proc initRect2*(pos, size: Vector2): Rect2 {.inline.} = +{.push stackTrace: off.} + +proc initRect2*(): Rect2 {.inline, noinit.} = + Rect2() + +proc initRect2*(pos, size: Vector2): Rect2 {.inline, noinit.} = Rect2(position: pos, size: size) -proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline.} = +proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline, noinit.} = Rect2(position: vec2(x, y), size: vec2(sizeX, sizeY)) proc `$`*(self: Rect2): string {.inline.} = $getGDNativeAPI().rect2AsString(self) -proc area*(self: Rect2): float32 {.inline.} = - getGDNativeAPI().rect2GetArea(self) +proc area*(self: Rect2): float32 {.inline, noinit.} = + self.size.x * self.size.y -proc intersects*(a, b: Rect2): bool {.inline.} = - getGDNativeAPI().rect2Intersects(a, b) +proc intersects*(a, b: Rect2): bool {.inline, noinit.} = + if a.position.x >= (b.position.x + b.size.x): + return false + if a.position.x + a.size.x <= b.position.x: + return false + if a.position.y >= (b.position.y + b.size.y): + return false + if a.position.y + a.size.y <= b.position.y: + return false + result = true -proc encloses*(a, b: Rect2): bool {.inline.} = - getGDNativeAPI().rect2Encloses(a, b) +proc distanceTo*(self: Rect2, p: Vector2): float32 {.noinit.} = + var inside = true + if p.x < self.position.x: + let d = self.position.x - p.x + result = d + inside = false + if p.y < self.position.y: + let d = self.position.y - p.y + result = if inside: d else: min(result, d) + inside = false + if p.x >= (self.position.x + self.size.x): + let d = p.x - (self.position.x + self.size.x) + result = if inside: d else: min(result, d) + inside = false + if p.y >= (self.position.y + self.size.y): + let d = p.y - (self.position.y + self.size.y) + result = if inside: d else: min(result, d) + inside = false -proc hasNoArea*(self: Rect2): bool {.inline.} = - getGDNativeAPI().rect2HasNoArea(self) + if inside: + result = 0'f32 -proc clip*(self, b: Rect2): Rect2 {.inline.} = - getGDNativeAPI().rect2Clip(self, b) +proc encloses*(a, b: Rect2): bool {.inline, noinit.} = + b.position.x >= a.position.x and b.position.y >= a.position.y and + (b.position.x + b.size.x) < (a.position.x + a.size.x) and + (b.position.y + b.size.y) < (a.position.y + a.size.y) -proc merge*(self, b: Rect2): Rect2 {.inline.} = - getGDNativeAPI().rect2Merge(self, b) +proc hasNoArea*(self: Rect2): bool {.inline, noinit.} = + self.size.x <= 0 or self.size.y <= 0 -proc contains*(self: Rect2; point: Vector2): bool {.inline.} = - getGDNativeAPI().rect2HasPoint(self, point) +proc clip*(self, b: Rect2): Rect2 {.inline, noinit.} = + if not self.intersects(b): + return initRect2() -proc grow*(self: Rect2; by: float32): Rect2 {.inline.} = - getGDNativeAPI().rect2Grow(self, by) + result = self -proc expand*(self: Rect2; to: Vector2): Rect2 {.inline.} = - getGDNativeAPI().rect2Expand(self, to) + result.position.x = max(b.position.x, self.position.x) + result.position.y = max(b.position.y, self.position.y) -proc `==`*(a, b: Rect2): bool {.inline.} = - getGDNativeAPI().rect2OperatorEqual(a, b) + let bEnd = b.position + b.size + let selfEnd = self.position + self.size + + result.size.x = min(bEnd.x, selfEnd.x) - result.position.x + result.size.y = min(bEnd.y, selfEnd.y) - result.position.y + +proc merge*(self, b: Rect2): Rect2 {.inline, noinit.} = + result.position.x = min(b.position.x, self.position.x) + result.position.y = min(b.position.y, self.position.y) + + result.size.x = max(b.position.x + b.size.x, self.position.x + self.size.x) + result.size.y = max(b.position.y + b.size.y, self.position.y + self.size.y) + result.size -= result.position + +proc contains*(self: Rect2; point: Vector2): bool {.inline, noinit.} = + if point.x < self.position.x: + return false + if point.y < self.position.y: + return false + + if point.x >= self.position.x + self.size.x: + return false + if point.y >= self.position.y + self.size.y: + return false + + result = true + +proc grow*(self: Rect2; by: float32): Rect2 {.inline, noinit.} = + ## Returns Rect2 enlarged by the specified size in every direction. + result = self + + result.position.x -= by + result.position.y -= by + + result.size.x += by * 2 + result.size.y += by * 2 + +proc growIndividual*(self: Rect2, left, top: float32, + right, bottom: float32): Rect2 {.inline, noinit.} = + result = self + result.position.x -= left + result.position.y -= top + result.size.x += left + right + result.size.y += top + bottom + +proc expandTo*(self: var Rect2, to: Vector2) {.inline.} = + var startPoint = self.position + var endPoint = self.position + self.size + + if to.x < startPoint.x: + startPoint.x = to.x + if to.y < startPoint.y: + startPoint.y = to.y + + if to.x > endPoint.x: + endPoint.x = to.x + if to.y > endPoint.y: + endPoint.y = to.y + + self.position = startPoint + self.size = endPoint - startPoint + +proc expand*(self: Rect2; to: Vector2): Rect2 {.inline, noinit.} = + result = self + result.expandTo(to) + +proc abs*(self: Rect2): Rect2 {.inline, noinit.} = + Rect2(position: vec2(self.position.x + min(self.size.x, 0'f32), + self.position.y + min(self.size.y, 0'f32)), + size: abs(self.size)) + +proc `==`*(a, b: Rect2): bool {.inline, noinit.} = + a.position == b.position and a.size == b.size + +{.pop.} # stackTrace: off \ No newline at end of file diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index b665dbd..f15bd2f 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -1,125 +1,199 @@ # Copyright (c) 2018 Xored Software, Inc. +import math, godotbase + import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi -proc vec2*(): Vector2 {.inline.} = +{.push stackTrace: off.} + +proc vec2*(): Vector2 {.inline, noinit.} = Vector2() -proc vec2*(x, y: float32): Vector2 {.inline.} = +proc vec2*(x, y: float32): Vector2 {.inline, noinit.} = Vector2(x: x, y: y) -proc `$`*(self: Vector2): string {.inline.} = +proc `$`*(self: Vector2): string {.inline, noinit.} = $getGDNativeAPI().vector2AsString(self) -proc normalized*(self: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Normalized(self) +proc `+`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x + other.x, y: self.y + other.y) -proc length*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2Length(self) +proc `+=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x += other.x + self.y += other.y -proc angle*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2Angle(self) +proc `-`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x - other.x, y: self.y - other.y) -proc lengthSquared*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2LengthSquared(self) +proc `-=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x -= other.x + self.y -= other.y -proc isNormalized*(self: Vector2): bool {.inline.} = - getGDNativeAPI().vector2IsNormalized(self) +proc `*`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x * other.x, y: self.y * other.y) -proc distanceTo*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2DistanceTo(self, to) +proc `*=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x *= other.x + self.y *= other.y -proc distanceSquaredTo*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2DistanceSquaredTo(self, to) +proc `*`*(self: Vector2, scalar: float32): Vector2 {.inline, noinit.} = + Vector2(x: self.x * scalar, y: self.y * scalar) -proc angleTo*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2AngleTo(self, to) +proc `*`*(scalar: float32, v: Vector2): Vector2 {.inline, noinit.} = + v * scalar -proc angleToPoint*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2AngleToPoint(self, to) +proc `*=`*(self: var Vector2, scalar: float32) {.inline, noinit.} = + self.x *= scalar + self.y *= scalar -proc lerp*(self, b: Vector2; t: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2LinearInterpolate(self, b, t) +proc `/`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x / other.x, y: self.y / other.y) -proc cubicInterpolate*(self, b, preA, postB: Vector2; - t: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2CubicInterpolate(self, b, preA, postB, t) +proc `/=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x /= other.x + self.y /= other.y -proc rotated*(self: Vector2; phi: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2Rotated(self, phi) +proc `/`*(self: Vector2; scalar: float32): Vector2 {.inline, noinit.} = + Vector2(x: self.x / scalar, y: self.y / scalar) -proc tangent*(self: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Tangent(self) - -proc floor*(self: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Floor(self) - -proc snapped*(self: Vector2; by: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Snapped(self, by) - -proc aspect*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2Aspect(self) - -proc dot*(a, b: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2Dot(a, b) - -proc slide*(self, n: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Slide(self, n) - -proc bounce*(self, n: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Bounce(self, n) - -proc reflect*(self, n: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Reflect(self, n) - -proc abs*(self: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Abs(self) - -proc clamped*(self: Vector2; length: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2Clamped(self, length) - -proc `+`*(self, other: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2OperatorAdd(self, other) - -proc `+=`*(self: var Vector2, other: Vector2) {.inline.} = - self = self + other - -proc `-`*(self, other: Vector2): Vector2 = - getGDNativeAPI().vector2OperatorSubtract(self, other) - -proc `-=`*(self: var Vector2, other: Vector2) {.inline.} = - self = self - other - -proc `*`*(self, other: Vector2): Vector2 = - getGDNativeAPI().vector2OperatorMultiplyVector(self, other) - -proc `*=`*(self: var Vector2, other: Vector2) {.inline.} = - self = self * other - -proc `*`*(self: Vector2, scalar: float32): Vector2 = - getGDNativeAPI().vector2OperatorMultiplyScalar(self, scalar) - -proc `*=`*(self: var Vector2, scalar: float32) {.inline.} = - self = self * scalar - -proc `/`*(self, other: Vector2): Vector2 = - getGDNativeAPI().vector2OperatorDivideVector(self, other) - -proc `/=`*(self: var Vector2, other: Vector2) {.inline.} = - self = self / other - -proc `/`*(self: Vector2; scalar: float32): Vector2 = - getGDNativeAPI().vector2OperatorDivideScalar(self, scalar) - -proc `/=`*(self: var Vector2; scalar: float32) {.inline.} = +proc `/=`*(self: var Vector2; scalar: float32) {.inline, noinit.} = self = self / scalar -proc `==`*(self, other: Vector2): bool {.inline.} = - getGDNativeAPI().vector2OperatorEqual(self, other) +proc `==`*(self, other: Vector2): bool {.inline, noinit.} = + self.x == other.x and self.y == other.y -proc `<`*(self, other: Vector2): bool {.inline.} = - getGDNativeAPI().vector2OperatorLess(self, other) +proc `<`*(self, other: Vector2): bool {.inline, noinit.} = + if self.x == other.x: + self.y < other.y + else: + self.x < other.x -proc `-`*(self: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2OperatorNeg(self) +proc `>`*(self, other: Vector2): bool {.inline, noinit.} = + if self.x == other.x: + self.y > other.y + else: + self.x > other.x + +proc `-`*(self: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: -self.x, y: -self.y) + +proc length*(self: Vector2): float32 {.inline, noinit.} = + sqrt(self.x * self.x + self.y * self.y) + +proc lengthSquared*(self: Vector2): float32 {.inline, noinit.} = + self.x * self.x + self.y * self.y + +proc normalize(self: var Vector2) {.inline.} = + var len = self.x * self.x + self.y * self.y + if len != 0: + len = sqrt(len) + self.x /= len + self.y /= len + +proc normalized*(self: Vector2): Vector2 {.inline, noinit.} = + result = self + result.normalize() + +proc angle*(self: Vector2): float32 {.inline, noinit.} = + arctan2(self.y, self.x) + +proc isNormalized*(self: Vector2): bool {.inline, noinit.} = + isEqualApprox(self.lengthSquared(), 1.0) + +proc distanceTo*(self, to: Vector2): float32 {.inline, noinit.} = + sqrt((self.x - to.x) * (self.x - to.x) + (self.y - to.y) * (self.y - to.y)) + +proc distanceSquaredTo*(self, to: Vector2): float32 {.inline, noinit.} = + (self.x - to.x) * (self.x - to.x) + (self.y - to.y) * (self.y - to.y) + +proc dot*(a, b: Vector2): float32 {.inline, noinit.} = + a.x * b.x + a.y * b.y + +proc cross*(a, b: Vector2): float32 {.inline, noinit.} = + a.x * b.y - a.y * b.x + +proc cross*(self: Vector2, scalar: float32): Vector2 {.inline, noinit.} = + Vector2(x: scalar * self.y, y: -scalar * self.x) + +proc angleTo*(self, to: Vector2): float32 {.noinit.} = + arctan2(cross(self, to), dot(self, to)) + +proc angleToPoint*(self, to: Vector2): float32 {.inline, noinit.} = + arctan2(self.y - to.y, self.x - to.x) + +proc floor*(self: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: floor(self.x), y: floor(self.y)) + +proc planeProject*(self: Vector2, d: float32, + vec: Vector2): Vector2 {.noinit.} = + vec - self * (self.dot(vec) - d) + +proc project*(self, other: Vector2): Vector2 {.noinit.} = + self * (other.dot(self) / self.dot(self)) + +proc lerp*(self, b: Vector2; t: float32): Vector2 {.inline, noinit.} = + result = self + result.x += t * (b.x - self.x) + result.y += t * (b.y - self.y) + +proc cubicInterpolate*(self, b, preA, postB: Vector2; + t: float32): Vector2 {.noinit.} = + let p0 = preA + let p1 = self + let p2 = b + let p3 = postB + + let t2 = t * t + let t3 = t2 * t + + result = 0.5'f32 * ((p1 * 2.0'f32)) + + (-p0 + p2) * t + + (2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 + + (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3 + +proc setRotation*(self: var Vector2, radians: float32) {.inline, noinit.} = + self.x = cos(radians) + self.y = sin(radians) + +proc rotated*(self: Vector2; phi: float32): Vector2 {.inline, noinit.} = + result.setRotation(phi) + result *= self.length() + +proc tangent*(self: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.y, y: -self.x) + +proc snapped*(self: Vector2; by: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: stepify(self.x, by.x), y: stepify(self.y, by.y)) + +proc aspect*(self: Vector2): float32 {.inline, noinit.} = + self.x / self.y + +proc slide*(self, n: Vector2): Vector2 {.noinit.} = + when not defined(release): + if not n.isNormalized(): + printError("Normal not normalized in slide. " & getStackTrace()) + return vec2() + result = self - n * self.dot(n) + +proc reflect*(self, n: Vector2): Vector2 {.noinit.} = + when not defined(release): + if not n.isNormalized(): + printError("Normal not normalized in bounce. " & getStackTrace()) + return vec2() + result = 2.0 * n * self.dot(n) - self + +proc bounce*(self, n: Vector2): Vector2 {.inline, noinit.} = + -self.reflect(n) + +proc abs*(self: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: abs(self.x), y: abs(self.y)) + +proc clamped*(self: Vector2; length: float32): Vector2 {.noinit.} = + let len = self.length() + result = self + if len > 0 and length < len: + result /= len + result *= length + +{.pop.} # stackTrace: off diff --git a/godot/core/vector3.nim b/godot/core/vector3.nim index f90bcfa..4ed9922 100644 --- a/godot/core/vector3.nim +++ b/godot/core/vector3.nim @@ -3,6 +3,8 @@ import math import godotbase, godotcoretypes +{.push stackTrace: off.} + proc vec3*(): Vector3 {.inline.} = Vector3() @@ -233,3 +235,5 @@ proc cubicInterpolate*(self, b, preA, postB: Vector3; (-p0 + p2) * t + (2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3) + +{.pop.} # stackTrace: off \ No newline at end of file diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index b989bda..3d64f1f 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -2,7 +2,7 @@ import tables, typetraits, macros import gdnativeapi -import core.godotcoretypes +import core.godotcoretypes, core.godotbase import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes, core.quats, core.aabb, @@ -92,25 +92,6 @@ type proc isFinalized*(obj: NimGodotObject): bool {.inline.} = obj.isFinalized -template printWarning*(warning: typed) = - ## Prints ``warning`` to Godot log, adding filename and line information. - let (filename, line) = instantiationInfo() - godotPrintWarning(cstring($warning), cstring"", cstring(filename), line.cint) - -template printError*(error: typed) = - ## Prints ``error`` to Godot log, adding filename and line information. - let (filename, line) = instantiationInfo() - godotPrintError(cstring($error), cstring"", cstring(filename), line.cint) - -proc print*(parts: varargs[string, `$`]) = - ## Prints concatenated ``parts`` to Godot log. - var combined = "" - for v in parts: - combined.add(v) - var s = combined.toGodotString() - godotPrint(s) - s.deinit() - var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo] var classRegistryStatic* {.compileTime.}: TableRef[cstring, ObjectInfo] ## Compile-time variable used for implementation of several procedures From be6f01e3b7517f1a6dff17fb0fea84a1b7c94c03 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 22 Feb 2018 18:55:52 +0700 Subject: [PATCH 116/160] More pool array features: subarray, mitems, mpairs --- godot.nimble | 2 +- godot/core/poolarrays.nim | 26 +- godot/gdnativeapi.nim | 466 ++++++++++++++++++++++---- godot/internal/godotinternaltypes.nim | 34 ++ godot/internal/godotpoolarrays.nim | 123 ++++++- 5 files changed, 559 insertions(+), 92 deletions(-) diff --git a/godot.nimble b/godot.nimble index e562fca..b60be93 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.6" +version = "0.7.7" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 55ce845..8206662 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -48,6 +48,12 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; proc len*(self: T): int {.inline.} = self.fieldName.len.int + proc subarray*(self: T, idxFrom, idxTo: int): T {.inline.} = + ## Indexes are inclusive, negative values count from the end of the array. + assert(idxFrom >= low(cint) and idxFrom <= high(cint) and + idxTo >= low(cint) and idxTo <= high(cint)) + newProcName(self.fieldName.subarray(idxFrom.cint, idxTo.cint)) + when not noData: proc add*(self: T; data: DataT) {.inline.} = self.fieldName.add(data) @@ -62,12 +68,20 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; self.fieldName[idx.cint] iterator items*(arr: T): DataT = - for i in 0..= ownLen: + let (file, line) = instantiationInfo() + getGDNativeAPI().printError( + cstring"Invalid subarray begin index", cstring"subarray", file, line.cint) + return + if actualIdxTo < 0 or actualIdxTo >= ownLen: + let (file, line) = instantiationInfo() + getGDNativeAPI().printError( + cstring"Invalid subarray end index", cstring"subarray", file, line.cint) + return + let span = actualIdxTo - actualIdxFrom + 1 + result.setLen(span) + let readAccess = getGDNativeAPI().readProc(self) + let writeAccess = getGDNativeAPI().writeProc(result) + let readPtr = getGDNativeAPI().readAccessPtrProc(readAccess).offset(actualIdxFrom) + copyMem(getGDNativeAPI().writeAccessPtrProc(writeAccess), readPtr, span) + getGDNativeAPI().readAccessDestroyProc(readAccess) + getGDNativeAPI().writeAccessDestroyProc(writeAccess) genPoolArrayAPI(GodotPoolByteArray, initGodotPoolByteArray, byte, poolByteArrayNew, @@ -70,7 +123,13 @@ genPoolArrayAPI(GodotPoolByteArray, initGodotPoolByteArray, byte, poolByteArraySet, poolByteArrayGet, poolByteArraySize, - poolByteArrayDestroy) + poolByteArrayDestroy, + poolByteArrayRead, + poolByteArrayWrite, + poolByteArrayReadAccessPtr, + poolByteArrayWriteAccessPtr, + poolByteArrayReadAccessDestroy, + poolByteArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint, poolIntArrayNew, @@ -86,7 +145,13 @@ genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint, poolIntArraySet, poolIntArrayGet, poolIntArraySize, - poolIntArrayDestroy) + poolIntArrayDestroy, + poolIntArrayRead, + poolIntArrayWrite, + poolIntArrayReadAccessPtr, + poolIntArrayWriteAccessPtr, + poolIntArrayReadAccessDestroy, + poolIntArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32, poolRealArrayNew, @@ -102,7 +167,13 @@ genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32, poolRealArraySet, poolRealArrayGet, poolRealArraySize, - poolRealArrayDestroy) + poolRealArrayDestroy, + poolRealArrayRead, + poolRealArrayWrite, + poolRealArrayReadAccessPtr, + poolRealArrayWriteAccessPtr, + poolRealArrayReadAccessDestroy, + poolRealArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString, poolStringArrayNew, @@ -118,7 +189,13 @@ genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString, poolStringArraySet, poolStringArrayGet, poolStringArraySize, - poolStringArrayDestroy) + poolStringArrayDestroy, + poolStringArrayRead, + poolStringArrayWrite, + poolStringArrayReadAccessPtr, + poolStringArrayWriteAccessPtr, + poolStringArrayReadAccessDestroy, + poolStringArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2, poolVector2ArrayNew, @@ -134,7 +211,13 @@ genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2, poolVector2ArraySet, poolVector2ArrayGet, poolVector2ArraySize, - poolVector2ArrayDestroy) + poolVector2ArrayDestroy, + poolVector2ArrayRead, + poolVector2ArrayWrite, + poolVector2ArrayReadAccessPtr, + poolVector2ArrayWriteAccessPtr, + poolVector2ArrayReadAccessDestroy, + poolVector2ArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3, poolVector3ArrayNew, @@ -150,7 +233,13 @@ genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3, poolVector3ArraySet, poolVector3ArrayGet, poolVector3ArraySize, - poolVector3ArrayDestroy) + poolVector3ArrayDestroy, + poolVector3ArrayRead, + poolVector3ArrayWrite, + poolVector3ArrayReadAccessPtr, + poolVector3ArrayWriteAccessPtr, + poolVector3ArrayReadAccessDestroy, + poolVector3ArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color, poolColorArrayNew, @@ -166,4 +255,10 @@ genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color, poolColorArraySet, poolColorArrayGet, poolColorArraySize, - poolColorArrayDestroy) + poolColorArrayDestroy, + poolColorArrayRead, + poolColorArrayWrite, + poolColorArrayReadAccessPtr, + poolColorArrayWriteAccessPtr, + poolColorArrayReadAccessDestroy, + poolColorArrayWriteAccessDestroy) From dc6ebaf5757b82436d714a779855207c6009afe4 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sat, 31 Mar 2018 17:43:46 +0700 Subject: [PATCH 117/160] Fix GDNative API version check Fixes #18. --- godot.nimble | 2 +- godot/gdnativeapi.nim | 44 +++++++++++++++++++++++++++++-------------- 2 files changed, 31 insertions(+), 15 deletions(-) diff --git a/godot.nimble b/godot.nimble index b60be93..772875c 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.7" +version = "0.7.8" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 5090813..3ece69b 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -2907,7 +2907,8 @@ var gdNativeAPI: GDNativeAPI proc getGDNativeAPI*(): ptr GDNativeAPI {.inline.} = addr gdNativeAPI -proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = +proc setGDNativeAPIInternal(apiStruct: pointer, initOptions: ptr GDNativeInitOptions, + foundCoreApi: var bool, foundNativeScriptApi: var bool) = let header = cast[ptr GDNativeAPIHeader](apiStruct) if header.typ >= ord(low(GDNativeAPIType)).cuint and header.typ <= ord(high(GDNativeAPIType)).cuint: @@ -2915,7 +2916,7 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = case typ: of GDNativeCore: let coreApi = cast[ptr GDNativeCoreAPI1](apiStruct) - if coreApi[].version.major == 1: + if coreApi[].version.major == 1 and coreApi[].version.minor == 0: assign(gdNativeApi, coreApi[]): # Color API colorNewRGBA @@ -3505,15 +3506,14 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) = printWarning print + foundCoreApi = true for i in 0.cuint.. Date: Tue, 24 Apr 2018 11:12:49 +0700 Subject: [PATCH 118/160] Make godotapigen use getter return type for property types Fixes #20. --- godot.nimble | 2 +- godot/godotapigen.nim | 120 +++++++++++++++++++++++------------------- 2 files changed, 66 insertions(+), 56 deletions(-) diff --git a/godot.nimble b/godot.nimble index 772875c..d0814d8 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.8" +version = "0.7.9" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index c3c07cd..7d19d8e 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -659,15 +659,73 @@ proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string], meth: MethodInfo, withImplementation: bool) = doGenerateMethod(tree, methodBindRegistry, meth, withImplementation) +proc getMethodInfo(methodObj: JsonNode, types: Table[string, GodotType], + typ: GodotType): MethodInfo = + var origArgs = methodObj["arguments"] + var isBase = methodObj["is_virtual"].bval + if methodObj["is_virtual"].bval: + proc getMethod(typNode: JsonNode, methName: string): JsonNode = + for meth in typNode["methods"]: + if meth["is_virtual"].bval and + meth["name"].str == methName: return meth + var curTyp = types.getOrDefault(typ.baseName) + while not curTyp.isNil: + let meth = curTyp.jsonNode.getMethod(methodObj["name"].str) + if not meth.isNil: + origArgs = meth["arguments"] + isBase = false + curTyp = types.getOrDefault(curTyp.baseName) + + var args = newSeqOfCap[MethodArg](methodObj["arguments"].len + 1) + for arg in origArgs: + let typ = toNimType(types, arg["type"].str) + let defaultVal = if arg["has_default_value"].bval: arg["default_value"] + else: nil + args.add(MethodArg( + name: toNimStyle(arg["name"].str), typ: typ, + defaultVal: defaultVal)) + if methodObj["has_varargs"].bval: + args.add(MethodArg(name: "variantArgs", typ: "Variant", kind: ArgKind.VarArgs)) + + let godotName = methodObj["name"].str + var nimName = toNimStyle(godotName) + if not godotName.startsWith('_'): + for meth in typ.jsonNode["methods"]: + if meth["name"].str == '_' & godotName: + nimName = nimName & "Impl" + + let returnType = if methodObj["return_type"].str != "void": + toNimType(types, methodObj["return_type"].str) + else: nil + const discardableMethods = toSet(["emit_signal"]) + result = MethodInfo( + name: ident(nimName), + typ: typ, + godotName: methodObj["name"].str, + args: args, + returnType: returnType, + isVirtual: methodObj["is_virtual"].bval, + isBase: isBase, + isDiscardable: typ.godotName == "Object" and + methodObj["name"].str in discardableMethods + ) + +proc findMethod(obj: JsonNode, methName: string): JsonNode = + for meth in obj["methods"]: + if meth["name"].str == methName: + return meth + proc makeProperty(types: Table[string, GodotType], tree: PNode, methodBindRegistry: var HashSet[string], - typ: GodotType, - propertyObj: JsonNode, withImplementation: bool) = + typ: GodotType, propertyObj: JsonNode, obj: JsonNode, + withImplementation: bool) = let getterNameStr = toNimStyle(propertyObj["name"].str) - let getterName = ident(toNimStyle(propertyObj["name"].str)) + let getterName = ident(getterNameStr) let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) - let nimType = toNimType(types, propertyObj["type"].str) + let getter = findMethod(obj, propertyObj["getter"].str) + let nimType = if getter.isNil: toNimType(types, propertyObj["type"].str) + else: getMethodInfo(getter, types, typ).returnType let getterInfo = MethodInfo( name: getterName, typ: typ, @@ -693,10 +751,6 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, methodBindRegistry: var HashSet[string], typ: GodotType, methodObj: JsonNode, withImplementation: bool) = - let returnType = if methodObj["return_type"].str != "void": - toNimType(types, methodObj["return_type"].str) - else: nil - if not typ.isSingleton: # for singletons we don't generate Nim setters/getters, # but use plain procedures instead. That's because setter syntax is @@ -706,51 +760,7 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, prop["setter"].str == methodObj["name"].str: return - var args = newSeqOfCap[MethodArg](methodObj["arguments"].len + 1) - var origArgs = methodObj["arguments"] - var isBase = methodObj["is_virtual"].bval - if methodObj["is_virtual"].bval: - proc getMethod(typNode: JsonNode, methName: string): JsonNode = - for meth in typNode["methods"]: - if meth["is_virtual"].bval and - meth["name"].str == methName: return meth - var curTyp = types.getOrDefault(typ.baseName) - while not curTyp.isNil: - let meth = curTyp.jsonNode.getMethod(methodObj["name"].str) - if not meth.isNil: - origArgs = meth["arguments"] - isBase = false - curTyp = types.getOrDefault(curTyp.baseName) - - for arg in origArgs: - let typ = toNimType(types, arg["type"].str) - let defaultVal = if arg["has_default_value"].bval: arg["default_value"] - else: nil - args.add(MethodArg( - name: toNimStyle(arg["name"].str), typ: typ, - defaultVal: defaultVal)) - if methodObj["has_varargs"].bval: - args.add(MethodArg(name: "variantArgs", typ: "Variant", kind: ArgKind.VarArgs)) - - let godotName = methodObj["name"].str - var nimName = toNimStyle(godotName) - if not godotName.startsWith('_'): - for meth in typ.jsonNode["methods"]: - if meth["name"].str == '_' & godotName: - nimName = nimName & "Impl" - - const discardableMethods = toSet(["emit_signal"]) - let methodInfo = MethodInfo( - name: ident(nimName), - typ: typ, - godotName: methodObj["name"].str, - args: args, - returnType: returnType, - isVirtual: methodObj["is_virtual"].bval, - isBase: isBase, - isDiscardable: typ.godotName == "Object" and - methodObj["name"].str in discardableMethods - ) + let methodInfo = getMethodInfo(methodObj, types, typ) generateMethod(tree, methodBindRegistry, methodInfo, withImplementation) @@ -931,7 +941,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) = if not typ.isSingleton: for property in obj["properties"]: makeProperty(types, tree, methodBindRegsitry, typ, property, - withImplementation = false) + obj, withImplementation = false) for meth in obj["methods"]: makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = false) @@ -939,7 +949,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) = if not typ.isSingleton: for property in obj["properties"]: makeProperty(types, tree, methodBindRegsitry, typ, - property, withImplementation = true) + property, obj, withImplementation = true) for meth in obj["methods"]: makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = true) From a1d14819678b9406e5927f73019fdb67dbcf7a62 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 14 May 2018 21:15:11 +0700 Subject: [PATCH 119/160] Add a remark to thread enter warning --- godot.nimble | 2 +- godot/nim/godotnim.nim | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index d0814d8..aab9b94 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.9" +version = "0.7.10" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 3d64f1f..2d66ebd 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -823,6 +823,8 @@ proc registerFrameCallback*(cb: proc () {.closure.}) = else: idleCallbacks.add(cb) +{.push stackTrace: off.} + proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = var stackBottom {.volatile.}: pointer {.emit: """ @@ -840,7 +842,7 @@ proc godot_nativescript_thread_enter() {.cdecl, exportc, dynlib.} = when compileOption("threads"): setupForeignThreadGc() else: - const err = cstring"A foreign thread is created, but app is compiled without --threads:on. Bad things will happen if Nim code is invoked from this thread." + const err = cstring"A foreign thread is created, but app is compiled without --threads:on. Bad things will happen if Nim code is invoked from this thread. If you see this warning when running the editor and you don't actually use threads, ignore it." var s = err.toGodotString() godotPrint(s) s.deinit() @@ -848,3 +850,5 @@ proc godot_nativescript_thread_enter() {.cdecl, exportc, dynlib.} = proc godot_nativescript_thread_exit() {.cdecl, exportc, dynlib.} = when compileOption("threads"): teardownForeignThreadGc() + +{.pop.} # stackTrace: off From 96dfc7de904d36fe93321e41df861aacd9d205f4 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 16 May 2018 15:06:43 +0700 Subject: [PATCH 120/160] Fix for latest Nim --- godot.nimble | 2 +- godot/core/godotbase.nim | 8 ++++---- godot/internal/godotpoolarrays.nim | 8 ++++---- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/godot.nimble b/godot.nimble index aab9b94..b8bfed5 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.10" +version = "0.7.11" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index 38cca0f..d76f544 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -43,13 +43,13 @@ proc max*(x, y: float32): float32 {.inline, noinit.} = template printWarning*(warning: typed) = ## Prints ``warning`` to Godot log, adding filename and line information. - let (filename, line) = instantiationInfo() - godotPrintWarning(cstring($warning), cstring"", cstring(filename), line.cint) + let instInfo = instantiationInfo() + godotPrintWarning(cstring($warning), cstring"", cstring(instInfo.filename), instInfo.line.cint) template printError*(error: typed) = ## Prints ``error`` to Godot log, adding filename and line information. - let (filename, line) = instantiationInfo() - godotPrintError(cstring($error), cstring"", cstring(filename), line.cint) + let instInfo = instantiationInfo() + godotPrintError(cstring($error), cstring"", cstring(instInfo.filename), instInfo.line.cint) proc print*(parts: varargs[string, `$`]) = ## Prints concatenated ``parts`` to Godot log. diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index ede392c..fb80ad0 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -91,14 +91,14 @@ template genPoolArrayAPI(ArrayT, initIdent, DataT, initIdent(result) if actualIdxFrom < 0 or actualIdxFrom >= ownLen: - let (file, line) = instantiationInfo() + let instInfo = instantiationInfo() getGDNativeAPI().printError( - cstring"Invalid subarray begin index", cstring"subarray", file, line.cint) + cstring"Invalid subarray begin index", cstring"subarray", instInfo.filename, instInfo.line.cint) return if actualIdxTo < 0 or actualIdxTo >= ownLen: - let (file, line) = instantiationInfo() + let instInfo = instantiationInfo() getGDNativeAPI().printError( - cstring"Invalid subarray end index", cstring"subarray", file, line.cint) + cstring"Invalid subarray end index", cstring"subarray", instInfo.filename, instInfo.line.cint) return let span = actualIdxTo - actualIdxFrom + 1 result.setLen(span) From 21ca9a088b605f47284e846ddce1ed1dad1a3728 Mon Sep 17 00:00:00 2001 From: Jon Renner Date: Fri, 18 May 2018 17:34:53 -0500 Subject: [PATCH 121/160] export Vector2 normalize proc --- godot/core/vector2.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index f15bd2f..e7e77d0 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -84,7 +84,7 @@ proc length*(self: Vector2): float32 {.inline, noinit.} = proc lengthSquared*(self: Vector2): float32 {.inline, noinit.} = self.x * self.x + self.y * self.y -proc normalize(self: var Vector2) {.inline.} = +proc normalize*(self: var Vector2) {.inline.} = var len = self.x * self.x + self.y * self.y if len != 0: len = sqrt(len) From 8b1ac6d83526633faeadc9149510a5d35d8c8f34 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 08:48:08 +0700 Subject: [PATCH 122/160] Fix compilation with C++ backend. Fixes #25. --- godot/nim/godotnim.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 2d66ebd..8f3d6fb 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -774,7 +774,7 @@ proc fromVariant*[T: Table or TableRef](t: var T, result = ConversionResult.TypeError {.emit: """/*TYPESECTION*/ -void NimMain(void); +N_LIB_EXPORT N_CDECL(void, NimMain)(void); N_NOINLINE(void, setStackBottom)(void* thestackbottom); """.} From 651c2d823c44e57d12b295291e6f7dd3e25cd77e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 09:24:54 +0700 Subject: [PATCH 123/160] Handle nil object references properly Fixes #26. --- godot/godotapigen.nim | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 7d19d8e..32275b4 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -468,9 +468,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), newCall("toGodotString", argName)))) else: + let objVal = newIfStmt( + prefix("not", newDotExpr(argName, ident"isNil")), + newDotExpr(argName, ident("godotObject")) + ).addChain(newNode(nkElse).addChain(newNilLit())) argConversions.add(newNode(nkLetSection).addChain( - newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), - newDotExpr(argName, ident("godotObject"))))) + newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), objVal))) let argAsgn = newNode(nkAsgn).addChain( newNode(nkBracketExpr).addChain( newNode(nkBracketExpr).addChain(argsName), argIdx), From 2dd0130c784161a6a2cf983b5d0ba86cd40497aa Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 09:51:07 +0700 Subject: [PATCH 124/160] Avoid name clashes between properties and methods Fixes #19. --- godot/godotapigen.nim | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 32275b4..ed444ff 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -722,6 +722,11 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode, methodBindRegistry: var HashSet[string], typ: GodotType, propertyObj: JsonNode, obj: JsonNode, withImplementation: bool) = + for meth in obj["methods"]: + if meth["name"].str == '_' & propertyObj["name"].str: + # Don't generate properties if there is a name clash - otherwise + # using the property would not compile due to ambiguity. + return let getterNameStr = toNimStyle(propertyObj["name"].str) let getterName = ident(getterNameStr) let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) @@ -760,8 +765,14 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, # supposed to be used on an object (have at least 2 params). for prop in typ.jsonNode["properties"]: if prop["getter"].str == methodObj["name"].str or - prop["setter"].str == methodObj["name"].str: - return + prop["setter"].str == methodObj["name"].str: + var hasDuplicateMethod = false + for meth in typ.jsonNode["methods"]: + if meth["name"].str == '_' & prop["name"].str: + hasDuplicateMethod = true + break + if not hasDuplicateMethod: + return let methodInfo = getMethodInfo(methodObj, types, typ) From 4eb771e9be50d6be5ede9783d13bfc41eb5b0a57 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 10:34:47 +0700 Subject: [PATCH 125/160] Support all the default values --- godot/godotapigen.nim | 45 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index ed444ff..ae9a8fa 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -319,6 +319,7 @@ proc singletonName(typ: string): PNode = proc makeDefaultValue(arg: MethodArg): PNode = result = newEmptyNode() if not arg.defaultVal.isNil: + var failed = false if arg.typ == "bool": result = ident(arg.defaultVal.str.toLowerAscii()) elif arg.typ in intTypes: @@ -335,15 +336,15 @@ proc makeDefaultValue(arg: MethodArg): PNode = elif arg.typ == "Color": result = newCall("initColor", arg.defaultVal.str.split(',').mapIt(newFloatLit(parseFloat(it)))) - # elif arg.typ in arrayTypes and (arg.defaultVal.str == "[]" or - # arg.defaultVal.str == "[" & arg.typ & "]"): - # result = newCall("init" & arg.typ) elif arg.typ == "RID" and arg.defaultVal.str == "[RID]": result = newCall("initRID") + elif arg.typ in arrayTypes and (arg.defaultVal.str == "[]" or + arg.defaultVal.str == "[" & arg.typ & "]"): + result = newCall("new" & arg.typ) elif arg.typ == "Vector2" or arg.typ == "Vector3" or arg.typ == "Rect2": let parts = arg.defaultVal.str.replace("(", "").replace(")", ""). replace(" ", ""). - split(",").mapIt(newFloatLit(parseFloat(it))) + split(',').mapIt(newFloatLit(parseFloat(it))) if arg.typ.endsWith("r2"): result = newCall("vec2", parts) elif arg.typ.endsWith('3'): @@ -352,11 +353,41 @@ proc makeDefaultValue(arg: MethodArg): PNode = result = newCall("initRect2", parts) elif arg.defaultVal.str == "[Object:null]": result = newNilLit() - elif arg.typ != "Transform" and arg.typ != "Transform2D" and - arg.typ != "Variant" and arg.typ notin arrayTypes: # TODO + elif arg.typ == "Transform": + let transformParts = arg.defaultVal.str.replace(" ", "").split('-') + doAssert(transformParts.len == 2) + let basisParts = transformParts[0].split(',').mapIt( + newFloatLit(parseFloat(it))) + let originParts = transformParts[1].split(',').mapIt( + newFloatLit(parseFloat(it))) + let basis = newCall("initBasis", basisParts) + let origin = newCall("vec3", originParts) + result = newCall("initTransform", basis, origin) + elif arg.typ == "Transform2D": + let parts = arg.defaultVal.str. + replace(" ", ""). + replace(")", ""). + replace("(", ""). + split(',').mapIt(newFloatLit(parseFloat(it))) + doAssert(parts.len == 6) + let xAxis = newCall("vec2", parts[0..1]) + let yAxis = newCall("vec2", parts[2..3]) + let origin = newCall("vec2", parts[4..5]) + result = newCall("initTransform2D", xAxis, yAxis, origin) + elif arg.typ == "Variant": + if arg.defaultVal.str == "0": + result = newCall("newVariant", newIntLit(0)) + elif arg.defaultVal.str == "Null": + result = newCall("newVariant") + else: + failed = true + else: + failed = true + + if failed: raise newException( ValueError, - "Cannot build default value from $# ($#)" % + "Cannot build default value from \"$#\" ($#) - please report this at https://github.com/pragmagic/godot-nim/issues" % [$arg.defaultVal, arg.typ]) proc boundArgName(idx: int): string = From 76de026b4fb7f3402a47d47b9b2fac9a48b643df Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 11:23:23 +0700 Subject: [PATCH 126/160] Implement hash proc for Godot types --- godot/core/aabb.nim | 6 +++ godot/core/basis.nim | 6 ++- godot/core/colors.nim | 5 +++ godot/core/dictionaries.nim | 9 ++-- godot/core/nodepaths.nim | 5 +++ godot/core/planes.nim | 5 +++ godot/core/poolarrays.nim | 13 ++++++ godot/core/quats.nim | 5 +++ godot/core/rect2.nim | 7 ++- godot/core/rids.nim | 5 +++ godot/core/transform2d.nim | 5 +++ godot/core/transforms.nim | 7 ++- godot/core/variants.nim | 89 ++++++++++++++++++++++++++----------- godot/core/vector2.nim | 5 ++- godot/core/vector3.nim | 5 ++- 15 files changed, 139 insertions(+), 38 deletions(-) diff --git a/godot/core/aabb.nim b/godot/core/aabb.nim index 88bf66a..2e9e7f0 100644 --- a/godot/core/aabb.nim +++ b/godot/core/aabb.nim @@ -1,5 +1,8 @@ # Copyright (c) 2018 Xored Software, Inc. +import hashes + +import vector3 import internal.godotinternaltypes, internal.godotstrings import godotcoretypes, gdnativeapi @@ -9,6 +12,9 @@ proc initAABB*(pos, size: Vector3): AABB {.inline.} = proc `$`*(self: AABB): string {.inline.} = $getGDNativeAPI().aabbAsString(self) +proc hash*(self: AABB): Hash {.inline.} = + !$(self.position.hash() !& self.size.hash()) + proc area*(self: AABB): float32 {.inline.} = getGDNativeAPI().aabbGetArea(self) diff --git a/godot/core/basis.nim b/godot/core/basis.nim index 538ca60..704f666 100644 --- a/godot/core/basis.nim +++ b/godot/core/basis.nim @@ -1,6 +1,7 @@ # Copyright (c) 2018 Xored Software, Inc. -import math +import math, hashes + import godotbase, vector3, quats import godotcoretypes @@ -201,6 +202,9 @@ proc `$`*(self: Basis): string {.inline.} = result.add(", ") result.add($self[i][j]) +proc hash*(self: Basis): Hash {.inline.} = + !$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash()) + template cofac(row1, col1, row2, col2: int): float32 = self.elements[row1][col1] * self.elements[row2][col2] - self.elements[row1][col2] * self.elements[row2][col1] diff --git a/godot/core/colors.nim b/godot/core/colors.nim index 46fcaf3..9079dad 100644 --- a/godot/core/colors.nim +++ b/godot/core/colors.nim @@ -1,5 +1,7 @@ # Copyright (c) 2018 Xored Software, Inc. +import hashes + import godotcoretypes, gdnativeapi proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} = @@ -33,6 +35,9 @@ proc `$`*(self: Color): string {.inline.} = result.add(", ") result.add($self.a) +proc hash*(self: Color): Hash {.inline.} = + !$(self.r.hash() !& self.g.hash() !& self.b.hash() !& self.a.hash()) + proc toHex(val: float32, target: var string, targetIdx: int) = let val = clamp(int(val * 255), 0, 255) let nums = [(val and 0xF0) shr 4, val and 0xF] diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 85970e5..99ecf6a 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -33,15 +33,15 @@ proc isEmpty*(self: Dictionary): bool {.inline.} = proc clear*(self: Dictionary) {.inline.} = self.godotDictionary.clear() +proc hash*(self: Dictionary): Hash {.inline.} = + hash(self.godotDictionary.godotHash()) + import variants, arrays proc newVariant*(dict: Dictionary): Variant {.inline.} = new(result, variantFinalizer) initGodotVariant(result.godotVariant[], dict.godotDictionary) -proc asDictionary*(self: Variant): Dictionary {.inline.} = - newDictionary(self.godotVariant[].asGodotDictionary) - proc contains*(self: Dictionary; key: Variant): bool {.inline.}= self.godotDictionary.contains(key.godotVariant[]) @@ -51,9 +51,6 @@ proc contains*(self: Dictionary; keys: Array): bool {.inline.} = proc del*(self: Dictionary; key: Variant) {.inline.} = self.godotDictionary.del(key.godotVariant[]) -proc hash*(self: Dictionary): Hash {.inline.} = - hash(self.godotDictionary.godotHash()) - proc keys*(self: Dictionary): Array {.inline.} = newArray(self.godotDictionary.keys()) diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index 428e261..831c855 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -1,5 +1,7 @@ # Copyright 2018 Xored Software, Inc. +import hashes + import internal.godotinternaltypes, internal.godotnodepaths, internal.godotstrings @@ -32,6 +34,9 @@ proc `$`*(self: NodePath): string {.inline.} = result = $s s.deinit() +proc hash*(self: NodePath): Hash {.inline.} = + ($self).hash() + proc isAbsolute*(self: NodePath): bool {.inline.} = self.path.isAbsolute() diff --git a/godot/core/planes.nim b/godot/core/planes.nim index 66de34e..b9420eb 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -1,5 +1,7 @@ # Copyright (c) 2018 Xored Software, Inc. +import hashes + import vector3 import internal.godotinternaltypes, internal.godotstrings @@ -20,6 +22,9 @@ proc initPlane*(normal: Vector3; d: float32): Plane {.inline.} = proc `$`*(self: Plane): string {.inline.} = $getGDNativeAPI().planeAsString(self) +proc hash*(self: Plane): Hash {.inline, noinit.} = + !$(self.normal.hash() !& self.d.hash()) + proc normalized*(self: Plane): Plane {.inline.} = getGDNativeAPI().planeNormalized(self) diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 8206662..3e7b73e 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -1,8 +1,11 @@ # Copyright 2018 Xored Software, Inc. +import hashes + import godotcoretypes import internal.godotinternaltypes, internal.godotpoolarrays, internal.godotstrings +import vector2, vector3, colors template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, initProcName) = @@ -83,6 +86,11 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; for pair in arr.fieldName.mpairs: yield (pair[0].int, pair[1]) + proc hash*(arr: T): Hash = + for item in arr.items(): + result = result !& item.hash() + result = !$result + definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8, godotPoolByteArray, newPoolByteArray, initGodotPoolByteArray) @@ -156,3 +164,8 @@ iterator items*(arr: PoolStringArray): string = iterator pairs*(arr: PoolStringArray): tuple[key: int, val: string] = for i in 0.. Date: Mon, 4 Jun 2018 11:47:17 +0700 Subject: [PATCH 127/160] Fix for latest Nim Closes #23. --- godot/internal/godotstrings.nim | 3 +-- godot/nim/godotnim.nim | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index d3eb287..17443cb 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -29,14 +29,13 @@ proc `$`*(self: GodotString): string = result = newString(length) copyMem(addr result[0], getGDNativeAPI().charStringGetData(charStr), length) getGDNativeAPI().charStringDestroy(charStr) - assert(result[length] == '\0') proc toGodotString*(s: string): GodotString {.inline.} = ## Converts the Nim string into ``GodotString`` if s.isNil: initGodotString(result) else: - initGodotString(result, unsafeAddr s[0], cint(s.len + 1)) + initGodotString(result, cstring(s), cint(s.len + 1)) proc toGodotString*(s: cstring): GodotString {.inline.} = ## Converts the cstring into ``GodotString`` diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 8f3d6fb..0b13477 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -297,8 +297,8 @@ macro toGodotName(T: typedesc): string = godotName = "float" elif T is SomeUnsignedInt or T is SomeSignedInt: godotName = "int" - if godotName.isNil: - let nameStr: string = (($T.getType()[1][1].symbol).split(':')[0]) + if godotName.isNil or godotName.len == 0: + let nameStr = (($T.getType()[1][1].symbol).split(':')[0]) godotName = case nameStr: of "File", "Directory", "Thread", "Mutex", "Semaphore": "_" & nameStr From 9e610308172d24d8adc8083e950eb90aec5df063 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 11:50:09 +0700 Subject: [PATCH 128/160] Up version to 0.7.12 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index b8bfed5..17968f8 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.11" +version = "0.7.12" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From 1e8ccfea2b8b25b78d4a5cd7ebcc4f29ff73b255 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 14:28:07 +0700 Subject: [PATCH 129/160] Fix handling of Error as an argument in Godot API --- godot/godotapigen.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index ae9a8fa..707154a 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -282,7 +282,7 @@ type const standardTypes = toSet( ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", - "uint64", + "uint64", "Error", "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", "Color", "RID", "NodePath", "Dictionary", "Variant", "Array", From b3ad6134d90aafd9da58050fd89943c492cc5351 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 4 Jun 2018 16:24:52 +0700 Subject: [PATCH 130/160] Fix doc generation --- docs/docbuild.nim | 3 ++- godot/core/dictionaries.nim | 3 +++ godot/core/poolarrays.nim | 16 ++++++---------- godot/core/variants.nim | 28 ++++++++++++++-------------- 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/docs/docbuild.nim b/docs/docbuild.nim index bb3e21c..10823a5 100644 --- a/docs/docbuild.nim +++ b/docs/docbuild.nim @@ -104,7 +104,8 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) = createDir(godotApiFolder) genApiFiles(godotApiFolder, godotBinAbs) for file in walkDirRec(godotApiFolder, {pcFile, pcDir}, [".nim"]): - spawn execOrFail("nim doc -d:useRealtimeGc --path:godot " & quoted(file)) + spawn execOrFail("nim doc -d:useRealtimeGc --path:godot -o:" & + quoted(outName(godotApiFolder, file)) & ' ' & quoted(file)) sync() diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 99ecf6a..4a160f2 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -42,6 +42,9 @@ proc newVariant*(dict: Dictionary): Variant {.inline.} = new(result, variantFinalizer) initGodotVariant(result.godotVariant[], dict.godotDictionary) +proc asDictionary*(self: Variant): Dictionary {.inline.} = + newDictionary(self.godotVariant[].asGodotDictionary()) + proc contains*(self: Dictionary; key: Variant): bool {.inline.}= self.godotDictionary.contains(key.godotVariant[]) diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 3e7b73e..29aca98 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -29,6 +29,12 @@ template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, new(result, poolArrayFinalizer) result.fieldName = arr + proc hash*(arr: T): Hash = + for item in arr.fieldName.items(): + result = result !& + (when type(item) is GodotString: ($item).hash() else: item.hash()) + result = !$result + template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; noData = false) = @@ -86,11 +92,6 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; for pair in arr.fieldName.mpairs: yield (pair[0].int, pair[1]) - proc hash*(arr: T): Hash = - for item in arr.items(): - result = result !& item.hash() - result = !$result - definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8, godotPoolByteArray, newPoolByteArray, initGodotPoolByteArray) @@ -164,8 +165,3 @@ iterator items*(arr: PoolStringArray): string = iterator pairs*(arr: PoolStringArray): tuple[key: int, val: string] = for i in 0.. Date: Mon, 4 Jun 2018 17:26:26 +0700 Subject: [PATCH 131/160] Up version to 0.7.13 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 17968f8..26afffa 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.12" +version = "0.7.13" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From 8d68051f23f54f343443bc025b06f162c654e90a Mon Sep 17 00:00:00 2001 From: Evgeny Zuev Date: Thu, 21 Jun 2018 16:46:00 +0700 Subject: [PATCH 132/160] Fix `system.of` being preferred over `godot.of` in some cases Fix `as` fails when argument `obj` is not convertible to `T` Up version to 0.7.14 --- godot.nimble | 2 +- godot/nim/godotnim.nim | 9 ++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/godot.nimble b/godot.nimble index 26afffa..e6c397f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.13" +version = "0.7.14" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 0b13477..4702a42 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -267,9 +267,9 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = ## This can be used either in dot notation (``node.as(Button)``) or ## infix notation (``node as Button``). if obj.isNil: return nil - if obj of T: + if system.`of`(obj, T): result = T(obj) - elif not obj.linkedObject.isNil and obj.linkedObject of T: + elif not obj.linkedObject.isNil and system.`of`(obj.linkedObject, T): result = T(obj.linkedObject) else: when not defined(release): @@ -277,10 +277,9 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = T.name & "\n" & getStackTrace()) result = nil -proc `of`*[T: NimGodotObject](obj: NimGodotObject, - t: typedesc[T]): bool {.inline.} = +proc `of`*[T1, T2: NimGodotObject](obj: T1, t: typedesc[T2]): bool {.inline.} = ## Godot-specific inheritance check. - not obj.isNil and (system.`of`(obj, T) or system.`of`(obj.linkedObject, T)) + not obj.isNil and (system.`of`(obj, T2) or system.`of`(obj.linkedObject, T2)) proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) From fd5f77e7c2ce68f17d5b50fc273b54112bf5aa55 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 14 Aug 2018 17:59:24 +0700 Subject: [PATCH 133/160] Fix gdobj to properly handle var block --- godot.nimble | 2 +- godot/nim/godotmacros.nim | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index e6c397f..fade4f8 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.14" +version = "0.7.15" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 384aa2b..3f1001b 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -172,7 +172,11 @@ proc parseMethod(meth: NimNode): MethodDecl = proc parseVarSection(decl: NimNode): seq[VarDecl] = assert(decl.kind == nnkVarSection) - result = identDefsToVarDecls(decl[0]) + for i in 0.. Date: Tue, 28 Aug 2018 14:05:33 +0700 Subject: [PATCH 134/160] Make `classRegistry` use hashes instead of strings as keys for faster lookup Up version to 0.7.16 --- godot.nimble | 2 +- godot/gdnativeapi.nim | 6 +- godot/godotapigen.nim | 4 +- godot/godotinternal.nim | 5 ++ godot/internal/godotinternaltypes.nim | 5 ++ godot/internal/godotpoolarrays.nim | 3 - godot/internal/godotstrings.nim | 6 ++ godot/nim/godotmacros.nim | 2 +- godot/nim/godotnim.nim | 91 ++++++++++++++++++++++----- 9 files changed, 101 insertions(+), 23 deletions(-) diff --git a/godot.nimble b/godot.nimble index fade4f8..60a1136 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.15" +version = "0.7.16" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 3ece69b..b24fc6f 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1374,7 +1374,8 @@ type stringNewWithWideString: pointer stringOperatorIndex: pointer stringOperatorIndexConst: pointer - stringWideStr: pointer + stringWideStr: proc (self: GodotString): ptr cwchar_t + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorEqual: proc (self, other: GodotString): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorLess: proc (self, other: GodotString): bool @@ -2811,6 +2812,8 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringNewCopy*: proc (dest: var GodotString, src: GodotString) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringWideStr*: proc (self: GodotString): ptr cwchar_t + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorEqual*: proc (self, other: GodotString): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} stringOperatorLess*: proc (self, other: GodotString): bool @@ -3481,6 +3484,7 @@ proc setGDNativeAPIInternal(apiStruct: pointer, initOptions: ptr GDNativeInitOpt stringNew stringNewCopy + stringWideStr stringOperatorEqual stringOperatorLess stringOperatorPlus diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 707154a..876e770 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -839,7 +839,7 @@ proc typeNameToModuleName(name: string): string = proc newRegisterClassNode(typ: GodotType): PNode = newCall("registerClass", ident(typ.name), - newCStringLit(typ.godotName), + newStrLit(typ.godotName), ident("true") # isNative ) @@ -877,7 +877,7 @@ proc genTypeFile(types: Table[string, GodotType], targetDir: string) = if not typ.shouldExport(types): continue let regNode = newCall("registerClass", ident(typ.name), - newCStringLit(typ.godotName), + newStrLit(typ.godotName), ident("true") # isNative ) godotApiTypesTree.add(regNode) diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index 0314624..ce83428 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -93,6 +93,11 @@ proc getClassName*(o: ptr GodotObject): string = # There are physics type not known by ClassDB result = result[0..result.len-3] +proc getClassNameRaw*(o: ptr GodotObject): GodotString = + if getClassMethodBind.isNil: + getClassMethodBind = getMethod(cstring"Object", cstring"get_class") + getClassMethodBind.ptrCall(o, nil, addr result) + proc getGodotSingleton*(name: cstring): ptr GodotObject {.inline.} = getGDNativeAPI().globalGetSingleton(name) diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim index 192b6cd..8474af8 100644 --- a/godot/internal/godotinternaltypes.nim +++ b/godot/internal/godotinternaltypes.nim @@ -66,6 +66,8 @@ type GodotString* {.byref.} = object data: array[sizeof(int), byte] + cwchar_t* {.importc: "wchar_t", nodecl.} = object + GodotCharString* {.byref.} = object data: array[sizeof(int), byte] @@ -305,3 +307,6 @@ type GodotClassConstructor* = proc (): ptr GodotObject {. noconv, gcsafe, locks: 0, raises: [], tags: [].} + +template offset*[T](p: ptr T, offset: int): ptr T = + cast[ptr T](cast[ByteAddress](p) +% (offset * sizeof(T))) \ No newline at end of file diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index fb80ad0..e03e1ff 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -3,9 +3,6 @@ import godotinternaltypes, gdnativeapi import core.godotcoretypes -proc offset[T](p: ptr T, offset: int): ptr T {.inline.} = - cast[ptr T](cast[ByteAddress](p) +% (offset * sizeof(T))) - template genPoolArrayAPI(ArrayT, initIdent, DataT, newProc, newCopyProc, newWithArrayProc, appendProc, appendArrayProc, insertProc, invertProc, pushBackProc, diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index 17443cb..be18df0 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -22,6 +22,12 @@ proc `&`*(self, b: GodotString): GodotString {.inline.} = proc deinit*(self: var GodotString) {.inline.} = getGDNativeAPI().stringDestroy(self) +proc len*(self: GodotString): cint {.inline.} = + getGDNativeAPI().stringLength(self) + +proc dataPtr*(self: GodotString): ptr cwchar_t {.inline.} = + getGDNativeAPI().stringWideStr(self) + proc `$`*(self: GodotString): string = ## Converts the ``GodotString`` into Nim string var charStr = getGDNativeAPI().stringUtf8(self) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 3f1001b..352925a 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -508,7 +508,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = # Register Godot object let parentName = if obj.parentName.isNil: newStrLitNode("Object") else: newStrLitNode(obj.parentName) - let classNameLit = newCStringLit(obj.name) + let classNameLit = newStrLitNode(obj.name) let classNameIdent = ident(obj.name) let isRef: bool = if obj.parentName.isNil: false else: obj.parentName in refClasses diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 4702a42..df682ca 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,6 +1,6 @@ # Copyright 2018 Xored Software, Inc. -import tables, typetraits, macros +import tables, typetraits, macros, unicode import gdnativeapi import core.godotcoretypes, core.godotbase import core.vector2, core.rect2, @@ -89,21 +89,71 @@ type ## values. ## See documentation of ``GodotPropertyHint`` for description of formats. + FNV1Hash = uint32 + proc isFinalized*(obj: NimGodotObject): bool {.inline.} = obj.isFinalized -var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo] -var classRegistryStatic* {.compileTime.}: TableRef[cstring, ObjectInfo] +var classRegistry {.threadvar.}: TableRef[FNV1Hash, ObjectInfo] +var classRegistryStatic* {.compileTime.}: TableRef[FNV1Hash, ObjectInfo] ## Compile-time variable used for implementation of several procedures ## and macros static: - classRegistryStatic = newTable[cstring, ObjectInfo]() + classRegistryStatic = newTable[FNV1Hash, ObjectInfo]() static: import sets, strutils var nativeClasses {.compileTime.} = newSeq[string]() var refClasses* {.compileTime.} = newSeq[string]() +template initFNV1Hash(hash: var FNV1Hash) = + hash = 0x811c9dc5'u32 + +template appendFNV1Hash(hash: var FNV1Hash, val: uint8) = + block: + let u64hash = hash.uint64 + hash = ( + u64hash + + (u64hash shl 1'u64) + + (u64hash shl 4'u64) + + (u64hash shl 7'u64) + + (u64hash shl 8'u64) + + (u64hash shl 24'u64)).uint32 xor val + +{.push stackTrace:off.} +proc lsb(c: ptr cwchar_t): char {.noinit, inline.} = + {.emit: [result, " = (char)(", c[]," & 0xFF);"]} +{.pop.} + +proc fnv1Hash(godotClassName: GodotString): FNV1Hash = + var charsCount = godotClassName.len + let charsPtr = godotClassName.dataPtr + if charsCount > 2 and + charsPtr.offset(charsCount - 2).lsb == 'S' and + charsPtr.offset(charsCount - 1).lsb == 'W': + charsCount -= 2 + + initFNV1Hash(result) + for i in 0..= charsCount: + break + let firstByte = uint8(rune.uint64 and 0xFF'u64) + appendFNV1Hash(result, firstByte) + # We don't really need to calculate hash of other bytes, + # since we only use hashes of ASCII strings + inc i + proc getClassName*(o: NimGodotObject): string = o.godotObject.getClassName() @@ -179,12 +229,12 @@ macro isResource(T: typedesc): bool = result = if inherits(getType(T), "Resource"): ident("true") else: ident("false") -template registerClass*(T: typedesc; godotClassName: cstring, +template registerClass*(T: typedesc; godotClassName: string or cstring, native: bool) = ## Registers the specified Godot type. ## Used by ``gdobj`` macro and `godotapigen `_. if classRegistry.isNil: - classRegistry = newTable[cstring, ObjectInfo]() + classRegistry = newTable[FNV1Hash, ObjectInfo]() let constructor = proc(): NimGodotObject = var t: T new(t, nimGodotObjectFinalizer[T]) @@ -198,14 +248,22 @@ template registerClass*(T: typedesc; godotClassName: cstring, isNative: native, isRef: isRef ) - classRegistry[godotClassName] = objInfo + classRegistry[fnv1Hash($godotClassName)] = objInfo static: let objInfoStatic = ObjectInfo( baseNativeClass: base, isNative: native, isRef: isRef, ) - classRegistryStatic[godotClassName] = objInfoStatic + let nameHash = fnv1Hash($godotClassName) + if not classRegistryStatic.contains(nameHash): + classRegistryStatic[nameHash] = objInfoStatic + elif not endsWith($godotClassName, "SW"): + # For simplicity we assume that all class names must have + # different hashes + # If this exception is ever raised, I guess, we should + # implement a proper collision resolving + raise newException(Exception, "Hash collision " & $godotClassName) when isRef: static: refClasses.add(T.name) @@ -214,10 +272,10 @@ template registerClass*(T: typedesc; godotClassName: cstring, nativeClasses.add(T.name) proc newNimGodotObject[T: NimGodotObject]( - godotObject: ptr GodotObject, godotClassName: cstring, noRef: bool): T = + godotObject: ptr GodotObject, godotClassName: GodotString, noRef: bool): T = assert(not classRegistry.isNil) assert(not godotObject.isNil) - let objInfo = classRegistry.getOrDefault(godotClassName) + let objInfo = classRegistry.getOrDefault(fnv1Hash(godotClassName)) if objInfo.constructor.isNil: printError("Nim constructor not found for class " & $godotClassName) else: @@ -240,9 +298,11 @@ proc asNimGodotObject*[T: NimGodotObject]( # Could be data from other bindings result = nil if result.isNil: + var classNameStr = godotObject.getClassNameRaw() result = newNimGodotObject[T]( - godotObject, cstring(godotObject.getClassName()), + godotObject, classNameStr, forceNativeObject or noRef) + deinit(classNameStr) proc newVariant*(obj: NimGodotObject): Variant {.inline.} = newVariant(obj.godotObject) @@ -363,17 +423,18 @@ proc newOwnObj[T: NimGodotObject](name: cstring): T = proc gdnew*[T: NimGodotObject](): T = ## Instantiates new object of type ``T``. - const godotName = asCString(toGodotName(T)) - const objInfo = classRegistryStatic[godotName] + const godotName = toGodotName(T) + const cGodotName = asCString(godotName) + const objInfo = classRegistryStatic[fnv1Hash(godotName)] when objInfo.isNative: - let godotObject = getClassConstructor(godotName)() + let godotObject = getClassConstructor(cGodotName)() new(result, nimGodotObjectFinalizer[T]) result.godotObject = godotObject when objInfo.isRef: godotObject.initRef() result.isRef = true else: - result = newOwnObj[T](godotName) + result = newOwnObj[T](cGodotName) proc newCallError*(err: VariantCallError): ref CallError = ## Instantiates ``CallError`` from Godot ``err``. From 859f9f04fb764fc81eae3e531c64a58cd5dfadaa Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 21 Sep 2018 16:34:09 +0700 Subject: [PATCH 135/160] OrderedTable to Variant conversion support --- godot.nimble | 2 +- godot/nim/godotnim.nim | 12 ++++++++---- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/godot.nimble b/godot.nimble index 60a1136..daabda8 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.16" +version = "0.7.17" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index df682ca..665b715 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -791,10 +791,10 @@ proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult = else: result = ConversionResult.TypeError -proc godotTypeInfo*(T: typedesc[Table|TableRef]): GodotTypeInfo {.inline.} = +proc godotTypeInfo*(T: typedesc[Table|TableRef|OrderedTable|OrderedTableRef]): GodotTypeInfo {.inline.} = result.variantType = VariantType.Dictionary -proc toVariant*[T: Table or TableRef](t: T): Variant = +proc toVariant*[T: Table or TableRef or OrderedTable or OrderedTableRef](t: T): Variant = when t is ref: if t.isNil: return newVariant() @@ -804,7 +804,7 @@ proc toVariant*[T: Table or TableRef](t: T): Variant = dict[toVariant(k)] = toVariant(v) result = newVariant(dict) -proc fromVariant*[T: Table or TableRef](t: var T, +proc fromVariant*[T: Table or TableRef or OrderedTable or OrderedTableRef](t: var T, val: Variant): ConversionResult = if val.getType() == VariantType.Nil: when t is ref: @@ -814,8 +814,12 @@ proc fromVariant*[T: Table or TableRef](t: var T, mixin fromVariant when t is Table: t = initTable[type(t.keys()), type(t.values())]() - else: + elif t is TableRef: t = newTable[type(t.keys()), type(t.values())]() + elif t is OrderedTable: + t = initOrderedTable[type(t.keys()), type(t.values())]() + else: + t = newOrderedTable[type(t.keys()), type(t.values())]() for k, v in dict: var nimKey: type(t.keys()) var nimVal: type(t.values()) From e9d73d8ec4612250f306737506e4507414f3d53e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Thu, 11 Oct 2018 19:06:05 +0700 Subject: [PATCH 136/160] Fix GDNative API procedure declarations Earlier signature mismatch caused problems on macOS with Godot 3.1. --- godot.nimble | 2 +- godot/core/aabb.nim | 16 +- godot/core/colors.nim | 8 +- godot/core/planes.nim | 10 +- godot/core/quats.nim | 22 +- godot/core/transform2d.nim | 32 +- godot/core/transforms.nim | 28 +- godot/gdnativeapi.nim | 466 ++++++++++++++++------------- godot/internal/godotpoolarrays.nim | 10 +- godot/internal/godotvariants.nim | 20 +- 10 files changed, 342 insertions(+), 272 deletions(-) diff --git a/godot.nimble b/godot.nimble index daabda8..8e4c8c0 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.17" +version = "0.7.18" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/aabb.nim b/godot/core/aabb.nim index 2e9e7f0..66425a2 100644 --- a/godot/core/aabb.nim +++ b/godot/core/aabb.nim @@ -31,10 +31,10 @@ proc encloses*(self, other: AABB): bool {.inline.} = getGDNativeAPI().aabbEncloses(self, other) proc merge*(self, other: AABB): AABB {.inline.} = - getGDNativeAPI().aabbMerge(self, other) + getGDNativeAPI().aabbMerge(self, other).toAABB() proc intersection*(self, other: AABB): AABB {.inline.} = - getGDNativeAPI().aabbIntersection(self, other) + getGDNativeAPI().aabbIntersection(self, other).toAABB() proc intersectsPlane*(self: AABB; plane: Plane): bool {.inline.} = getGDNativeAPI().aabbIntersectsPlane(self, plane) @@ -46,10 +46,10 @@ proc contains*(self: AABB; point: Vector3): bool {.inline.} = getGDNativeAPI().aabbHasPoint(self, point) proc getSupport*(self: AABB; dir: Vector3): Vector3 {.inline.} = - getGDNativeAPI().aabbGetSupport(self, dir) + getGDNativeAPI().aabbGetSupport(self, dir).toVector3() proc getLongestAxis*(self: AABB): Vector3 {.inline.} = - getGDNativeAPI().aabbGetLongestAxis(self) + getGDNativeAPI().aabbGetLongestAxis(self).toVector3() proc getLongestAxisIndex*(self: AABB): cint {.inline.} = getGDNativeAPI().aabbGetLongestAxisIndex(self) @@ -58,7 +58,7 @@ proc getLongestAxisSize*(self: AABB): float32 {.inline.} = getGDNativeAPI().aabbGetLongestAxisSize(self) proc getShortestAxis*(self: AABB): Vector3 {.inline.} = - getGDNativeAPI().aabbGetShortestAxis(self) + getGDNativeAPI().aabbGetShortestAxis(self).toVector3() proc getShortestAxisIndex*(self: AABB): cint {.inline.} = getGDNativeAPI().aabbGetShortestAxisIndex(self) @@ -67,13 +67,13 @@ proc getShortestAxisSize*(self: AABB): float32 {.inline.} = getGDNativeAPI().aabbGetShortestAxisSize(self) proc expand*(self: AABB; toPoint: Vector3): AABB {.inline.} = - getGDNativeAPI().aabbExpand(self, toPoint) + getGDNativeAPI().aabbExpand(self, toPoint).toAABB() proc grow*(self: AABB; by: float32): AABB {.inline.} = - getGDNativeAPI().aabbGrow(self, by) + getGDNativeAPI().aabbGrow(self, by).toAABB() proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} = - getGDNativeAPI().aabbGetEndpoint(self, idx) + getGDNativeAPI().aabbGetEndpoint(self, idx).toVector3() proc `==`*(a, b: AABB): bool {.inline.} = getGDNativeAPI().aabbOperatorEqual(a, b) diff --git a/godot/core/colors.nim b/godot/core/colors.nim index 9079dad..8e01b7a 100644 --- a/godot/core/colors.nim +++ b/godot/core/colors.nim @@ -64,16 +64,16 @@ proc gray*(self: Color): float32 {.inline.} = getGDNativeAPI().colorGray(self) proc inverted*(self: Color): Color {.inline.} = - getGDNativeAPI().colorInverted(self) + getGDNativeAPI().colorInverted(self).toColor() proc contrasted*(self: Color): Color {.inline.} = - getGDNativeAPI().colorContrasted(self) + getGDNativeAPI().colorContrasted(self).toColor() proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} = - getGDNativeAPI().colorLinearInterpolate(self, b, t) + getGDNativeAPI().colorLinearInterpolate(self, b, t).toColor() proc blend*(self: Color; over: Color): Color {.inline.} = - getGDNativeAPI().colorBlend(self, over) + getGDNativeAPI().colorBlend(self, over).toColor() proc `==`*(a, b: Color): bool {.inline.} = a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a diff --git a/godot/core/planes.nim b/godot/core/planes.nim index b9420eb..815a5c6 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -26,13 +26,13 @@ proc hash*(self: Plane): Hash {.inline, noinit.} = !$(self.normal.hash() !& self.d.hash()) proc normalized*(self: Plane): Plane {.inline.} = - getGDNativeAPI().planeNormalized(self) + getGDNativeAPI().planeNormalized(self).toPlane() proc center*(self: Plane): Vector3 {.inline.} = - getGDNativeAPI().planeCenter(self) + getGDNativeAPI().planeCenter(self).toVector3() proc getAnyPoint*(self: Plane): Vector3 {.inline.} = - getGDNativeAPI().planeGetAnyPoint(self) + getGDNativeAPI().planeGetAnyPoint(self).toVector3() proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} = getGDNativeAPI().planeIsPointOver(self, point) @@ -45,7 +45,7 @@ proc contains*(self: Plane; point: Vector3; getGDNativeAPI().planeHasPoint(self, point, epsilon) proc project*(self: Plane; point: Vector3): Vector3 {.inline.} = - getGDNativeAPI().planeProject(self, point) + getGDNativeAPI().planeProject(self, point).toVector3() proc intersect3*(self: Plane; dest: var Vector3; b, c: Plane): bool {.inline.} = @@ -60,7 +60,7 @@ proc intersectsSegment*(self: Plane; dest: var Vector3; getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd) proc `-`*(self: Plane): Plane {.inline.} = - getGDNativeAPI().planeOperatorNeg(self) + getGDNativeAPI().planeOperatorNeg(self).toPlane() proc `==`*(a, b: Plane): bool {.inline.} = getGDNativeAPI().planeOperatorEqual(a, b) diff --git a/godot/core/quats.nim b/godot/core/quats.nim index 560a341..1a8da82 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -29,50 +29,50 @@ proc lengthSquared*(self: Quat): float32 {.inline.} = getGDNativeAPI().quatLengthSquared(self) proc normalized*(self: Quat): Quat {.inline.} = - getGDNativeAPI().quatNormalized(self) + getGDNativeAPI().quatNormalized(self).toQuat() proc isNormalized*(self: Quat): bool {.inline.} = getGDNativeAPI().quatIsNormalized(self) proc inverse*(self: Quat): Quat {.inline.} = - getGDNativeAPI().quatInverse(self) + getGDNativeAPI().quatInverse(self).toQuat() proc dot*(a, b: Quat): float32 {.inline.} = getGDNativeAPI().quatDot(a, b) proc xform*(self: Quat; v: Vector3): Vector3 {.inline.} = - getGDNativeAPI().quatXform(self, v) + getGDNativeAPI().quatXform(self, v).toVector3() proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} = - getGDNativeAPI().quatSlerp(self, b, t) + getGDNativeAPI().quatSlerp(self, b, t).toQuat() proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} = - getGDNativeAPI().quatSlerpni(self, b, t) + getGDNativeAPI().quatSlerpni(self, b, t).toQuat() proc cubicSlerp*(self, b, preA, postB: Quat; t: float32): Quat {.inline.} = - getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t) + getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t).toQuat() proc `*`*(a: Quat, b: float32): Quat {.inline.} = - getGDNativeAPI().quatOperatorMultiply(a, b) + getGDNativeAPI().quatOperatorMultiply(a, b).toQuat() proc `*=`*(a: var Quat, b: float32) {.inline.} = a = a * b proc `+`*(a, b: Quat): Quat {.inline.} = - getGDNativeAPI().quatOperatorAdd(a, b) + getGDNativeAPI().quatOperatorAdd(a, b).toQuat() proc `+=`*(a: var Quat, b: Quat) {.inline.} = a = a + b proc `-`*(a, b: Quat): Quat {.inline.} = - getGDNativeAPI().quatOperatorSubtract(a, b) + getGDNativeAPI().quatOperatorSubtract(a, b).toQuat() proc `-=`* (a: var Quat, b: Quat) {.inline.} = a = a - b proc `/`*(self: Quat; b: float32): Quat {.inline.} = - getGDNativeAPI().quatOperatorDivide(self, b) + getGDNativeAPI().quatOperatorDivide(self, b).toQuat() proc `/=`*(self: var Quat, b: float32) {.inline.} = self = self / b @@ -81,4 +81,4 @@ proc `==`*(a, b: Quat): bool {.inline.} = getGDNativeAPI().quatOperatorEqual(a, b) proc `-`*(self: Quat): Quat {.inline.} = - getGDNativeAPI().quatOperatorNeg(self) + getGDNativeAPI().quatOperatorNeg(self).toQuat() diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index af3e9b4..16f62bd 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -21,59 +21,59 @@ proc hash*(self: Transform2D): Hash {.inline, noinit.} = !$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash()) proc inverse*(self: Transform2D): Transform2D {.inline.} = - getGDNativeAPI().transform2DInverse(self) + getGDNativeAPI().transform2DInverse(self).toTransform2D() proc affineInverse*(self: Transform2D): Transform2D {.inline.} = - getGDNativeAPI().transform2DAffineInverse(self) + getGDNativeAPI().transform2DAffineInverse(self).toTransform2D() proc rotation*(self: Transform2D): float32 {.inline.} = getGDNativeAPI().transform2DGetRotation(self) proc origin*(self: Transform2D): Vector2 {.inline.} = - getGDNativeAPI().transform2DGetOrigin(self) + getGDNativeAPI().transform2DGetOrigin(self).toVector2() proc scale*(self: Transform2D): Vector2 {.inline.} = - getGDNativeAPI().transform2DGetScale(self) + getGDNativeAPI().transform2DGetScale(self).toVector2() proc orthonormalized*(self: Transform2D): Transform2D {.inline.} = - getGDNativeAPI().transform2DOrthonormalized(self) + getGDNativeAPI().transform2DOrthonormalized(self).toTransform2D() proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} = - getGDNativeAPI().transform2DRotated(self, phi) + getGDNativeAPI().transform2DRotated(self, phi).toTransform2D() proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} = - getGDNativeAPI().transform2DScaled(self, scale) + getGDNativeAPI().transform2DScaled(self, scale).toTransform2D() proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} = - getGDNativeAPI().transform2DTranslated(self, offset) + getGDNativeAPI().transform2DTranslated(self, offset).toTransform2D() proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = - getGDNativeAPI().transform2DXformVector2(self, v) + getGDNativeAPI().transform2DXformVector2(self, v).toVector2() proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = - getGDNativeAPI().transform2DXformInvVector2(self, v) + getGDNativeAPI().transform2DXformInvVector2(self, v).toVector2() proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = - getGDNativeAPI().transform2DBasisXformVector2(self, v) + getGDNativeAPI().transform2DBasisXformVector2(self, v).toVector2() proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = - getGDNativeAPI().transform2DBasisXformInvVector2(self, v) + getGDNativeAPI().transform2DBasisXformInvVector2(self, v).toVector2() proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} = - getGDNativeAPI().transform2DXformRect2(self, rect) + getGDNativeAPI().transform2DXformRect2(self, rect).toRect2() proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} = - getGDNativeAPI().transform2DXformInvRect2(self, rect) + getGDNativeAPI().transform2DXformInvRect2(self, rect).toRect2() proc interpolateWith*(self, m: Transform2D; c: float32): Transform2D {.inline.} = - getGDNativeAPI().transform2DInterpolateWith(self, m, c) + getGDNativeAPI().transform2DInterpolateWith(self, m, c).toTransform2D() proc `==`*(a, b: Transform2D): bool {.inline.} = getGDNativeAPI().transform2DOperatorEqual(a, b) proc `*`*(a, b: Transform2D): Transform2D {.inline.} = - getGDNativeAPI().transform2DOperatorMultiply(a, b) + getGDNativeAPI().transform2DOperatorMultiply(a, b).toTransform2D() proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} = a = a * b diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index bb3aa05..4a21466 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -27,50 +27,50 @@ proc hash*(self: Transform): Hash {.inline.} = !$(self.basis.hash() !& self.origin.hash()) proc inverse*(self: Transform): Transform {.inline.} = - getGDNativeAPI().transformInverse(self) + getGDNativeAPI().transformInverse(self).toTransform() proc affineInverse*(self: Transform): Transform {.inline.} = - getGDNativeAPI().transformAffineInverse(self) + getGDNativeAPI().transformAffineInverse(self).toTransform() proc orthonormalized*(self: Transform): Transform {.inline.} = - getGDNativeAPI().transformOrthonormalized(self) + getGDNativeAPI().transformOrthonormalized(self).toTransform() proc rotated*(self: Transform; axis: Vector3; phi: float32): Transform {.inline.} = - getGDNativeAPI().transformRotated(self, axis, phi) + getGDNativeAPI().transformRotated(self, axis, phi).toTransform() proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} = - getGDNativeAPI().transformScaled(self, scale) + getGDNativeAPI().transformScaled(self, scale).toTransform() proc translated*(self: Transform; offset: Vector3): Transform {.inline.} = - getGDNativeAPI().transformTranslated(self, offset) + getGDNativeAPI().transformTranslated(self, offset).toTransform() proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} = - getGDNativeAPI().transformLookingAt(self, target, up) + getGDNativeAPI().transformLookingAt(self, target, up).toTransform() proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} = - getGDNativeAPI().transformXformPlane(self, plane) + getGDNativeAPI().transformXformPlane(self, plane).toPlane() proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} = - getGDNativeAPI().transformXformInvPlane(self, plane) + getGDNativeAPI().transformXformInvPlane(self, plane).toPlane() proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = - getGDNativeAPI().transformXformVector3(self, v) + getGDNativeAPI().transformXformVector3(self, v).toVector3() proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = - getGDNativeAPI().transformXformInvVector3(self, v) + getGDNativeAPI().transformXformInvVector3(self, v).toVector3() proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} = - getGDNativeAPI().transformXformAABB(self, rect) + getGDNativeAPI().transformXformAABB(self, rect).toAABB() proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} = - getGDNativeAPI().transformXformInvAABB(self, rect) + getGDNativeAPI().transformXformInvAABB(self, rect).toAABB() proc `==`*(self: Transform; b: Transform): bool {.inline.} = getGDNativeAPI().transformOperatorEqual(self, b) proc `*`*(self, other: Transform): Transform {.inline.} = - getGDNativeAPI().transformOperatorMultiply(self, other) + getGDNativeAPI().transformOperatorMultiply(self, other).toTransform() proc `*=`*(self: var Transform, other: Transform) {.inline.} = self = self * other diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index b24fc6f..591d45e 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -3,6 +3,36 @@ import internal.godotinternaltypes, core.godotcoretypes, macros type + ColorData* {.byref.} = object + data: array[16, uint8] + + Vector3Data* {.byref.} = object + data: array[12, uint8] + + Vector2Data* {.byref.} = object + data: array[8, uint8] + + PlaneData* {.byref.} = object + data: array[16, uint8] + + BasisData* {.byref.} = object + data: array[36, uint8] + + QuatData* {.byref.} = object + data: array[16, uint8] + + AABBData* {.byref.} = object + data: array[24, uint8] + + Rect2Data* {.byref.} = object + data: array[16, uint8] + + Transform2DData* {.byref.} = object + data: array[24, uint8] + + TransformData* {.byref.} = object + data: array[48, uint8] + GDNativeAPIType {.size: sizeof(cuint).} = enum GDNativeCore, GDNativeExtNativeScript, @@ -93,14 +123,14 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} colorGray: proc (self: Color): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorInverted: proc (self: Color): Color + colorInverted: proc (self: Color): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorContrasted: proc (self: Color): Color + colorContrasted: proc (self: Color): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorLinearInterpolate: proc (self, other: Color, t: float32): Color + colorLinearInterpolate: proc (self, other: Color, t: float32): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorBlend: proc (self, other: Color): Color + colorBlend: proc (self, other: Color): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} colorToHtml: proc (self: Color, withAlpha: bool): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -114,7 +144,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2AsString: proc (self: Vector2): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Normalized: proc (self: Vector2): Vector2 + vector2Normalized: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2Length: proc (self: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -133,57 +163,57 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2AngleToPoint: proc (self, to: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2LinearInterpolate: proc (self, b: Vector2, t: float32): Vector2 + vector2LinearInterpolate: proc (self, b: Vector2, t: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2CubicInterpolate: proc (self, b, preA, postB: Vector2, - t: float32): Vector2 + t: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Rotated: proc (self: Vector2, phi: float32): Vector2 + vector2Rotated: proc (self: Vector2, phi: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Tangent: proc (self: Vector2): Vector2 + vector2Tangent: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Floor: proc (self: Vector2): Vector2 + vector2Floor: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Snapped: proc (self, by: Vector2): Vector2 + vector2Snapped: proc (self, by: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2Aspect: proc (self: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2Dot: proc (self, other: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Slide: proc (self, n: Vector2): Vector2 + vector2Slide: proc (self, n: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Bounce: proc (self, n: Vector2): Vector2 + vector2Bounce: proc (self, n: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Reflect: proc (self, n: Vector2): Vector2 + vector2Reflect: proc (self, n: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Abs: proc (self: Vector2): Vector2 + vector2Abs: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Clamped: proc (self: Vector2, length: float32): Vector2 + vector2Clamped: proc (self: Vector2, length: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorAdd: proc (self, other: Vector2): Vector2 + vector2OperatorAdd: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorSubtract: proc (self, other: Vector2): Vector2 + vector2OperatorSubtract: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorMultiplyVector: proc (self, other: Vector2): Vector2 + vector2OperatorMultiplyVector: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorMultiplyScalar: proc (self: Vector2, scalar: float32): Vector2 + vector2OperatorMultiplyScalar: proc (self: Vector2, scalar: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorDivideVector: proc (self, other: Vector2): Vector2 + vector2OperatorDivideVector: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorDivideScalar: proc (self: Vector2, scalar: float32): Vector2 + vector2OperatorDivideScalar: proc (self: Vector2, scalar: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2OperatorEqual: proc (self, other: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2OperatorLess: proc (self, other: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorNeg: proc (self: Vector2): Vector2 + vector2OperatorNeg: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2SetX: pointer vector2SetY: pointer @@ -218,33 +248,33 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatLengthSquared: proc (self: Quat): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatNormalized: proc (self: Quat): Quat + quatNormalized: proc (self: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatIsNormalized: proc (self: Quat): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatInverse: proc (self: Quat): Quat + quatInverse: proc (self: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatDot: proc (self, other: Quat): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatXform: proc (self: Quat, v: Vector3): Vector3 + quatXform: proc (self: Quat, v: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSlerp: proc (self, other: Quat, t: float32): Quat + quatSlerp: proc (self, other: Quat, t: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSlerpni: proc (self, other: Quat, t: float32): Quat + quatSlerpni: proc (self, other: Quat, t: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatCubicSlerp: proc (self, other, preA, postB: Quat, t: float32): Quat + quatCubicSlerp: proc (self, other, preA, postB: Quat, t: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorMultiply: proc (self: Quat, b: float32): Quat + quatOperatorMultiply: proc (self: Quat, b: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorAdd: proc (self, other: Quat): Quat + quatOperatorAdd: proc (self, other: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorSubtract: proc (self, other: Quat): Quat + quatOperatorSubtract: proc (self, other: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorDivide: proc (self: Quat, divider: float32): Quat + quatOperatorDivide: proc (self: Quat, divider: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatOperatorEqual: proc (self, other: Quat): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorNeg: proc (self: Quat): Quat + quatOperatorNeg: proc (self: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # Basis API @@ -534,7 +564,7 @@ type poolVector2ArraySet: proc (self: var GodotPoolVector2Array, idx: cint, data: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArrayGet: proc (self: GodotPoolVector2Array, idx: cint): Vector2 + poolVector2ArrayGet: proc (self: GodotPoolVector2Array, idx: cint): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolVector2ArraySize: proc (self: GodotPoolVector2Array): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -583,7 +613,7 @@ type poolVector3ArraySet: proc (self: var GodotPoolVector3Array, idx: cint, data: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector3ArrayGet: proc (self: GodotPoolVector3Array, idx: cint): Vector3 + poolVector3ArrayGet: proc (self: GodotPoolVector3Array, idx: cint): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolVector3ArraySize: proc (self: GodotPoolVector3Array): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -628,7 +658,7 @@ type poolColorArraySet: proc (self: var GodotPoolColorArray, idx: cint, data: Color) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayGet: proc (self: GodotPoolColorArray, idx: cint): Color + poolColorArrayGet: proc (self: GodotPoolColorArray, idx: cint): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolColorArraySize: proc (self: GodotPoolColorArray): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -937,11 +967,11 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeAsString: proc (self: Plane): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeNormalized: proc (self: Plane): Plane + planeNormalized: proc (self: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeCenter: proc (self: Plane): Vector3 + planeCenter: proc (self: Plane): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetAnyPoint: proc (self: Plane): Vector3 + planeGetAnyPoint: proc (self: Plane): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeIsPointOver: proc (self: Plane, point: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -949,7 +979,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeHasPoint: proc (self: Plane, point: Vector3, epsilon: float32): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeProject: proc (self: Plane, point: Vector3): Vector3 + planeProject: proc (self: Plane, point: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeIntersect3: proc (self: Plane, dest: var Vector3, b, c: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -960,13 +990,13 @@ type segmentBegin, segmentEnd: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeOperatorNeg: proc (self: Plane): Plane + planeOperatorNeg: proc (self: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeOperatorEqual: proc (self, other: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeSetNormal: proc (self: var Plane, normal: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetNormal: proc (self: Plane): Vector3 + planeGetNormal: proc (self: Plane): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeGetD: proc (self: Plane): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -989,21 +1019,21 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2HasNoArea: proc (self: Rect2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Clip: proc (self, other: Rect2): Rect2 + rect2Clip: proc (self, other: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Merge: proc (self, other: Rect2): Rect2 + rect2Merge: proc (self, other: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2HasPoint: proc (self: Rect2, point: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Grow: proc (self: Rect2, by: float32): Rect2 + rect2Grow: proc (self: Rect2, by: float32): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Expand: proc (self: Rect2, to: Vector2): Rect2 + rect2Expand: proc (self: Rect2, to: Vector2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2OperatorEqual: proc (self, other: Rect2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetPosition: proc (self: Rect2): Vector2 + rect2GetPosition: proc (self: Rect2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetSize: proc (self: Rect2): Vector2 + rect2GetSize: proc (self: Rect2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2SetPosition: proc (self: var Rect2, pos: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1013,11 +1043,11 @@ type # AABB API aabbNew: proc (dest: var AABB, pos, size: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetPosition: proc (self: AABB): Vector3 + aabbGetPosition: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbSetPosition: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetSize: proc (self: AABB): Vector3 + aabbGetSize: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbSetSize: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1033,9 +1063,9 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbEncloses: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbMerge: proc (self, other: AABB): AABB + aabbMerge: proc (self, other: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbIntersection: proc (self, other: AABB): AABB + aabbIntersection: proc (self, other: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbIntersectsPlane: proc (self: AABB, plane: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1044,9 +1074,9 @@ type locks: 0.} aabbHasPoint: proc (self: AABB, point: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetSupport: proc (self: AABB, dir: Vector3): Vector3 + aabbGetSupport: proc (self: AABB, dir: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetLongestAxis: proc (self: AABB): Vector3 + aabbGetLongestAxis: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbGetLongestAxisIndex: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], @@ -1054,7 +1084,7 @@ type aabbGetLongestAxisSize: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetShortestAxis: proc (self: AABB): Vector3 + aabbGetShortestAxis: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbGetShortestAxisIndex: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], @@ -1062,11 +1092,11 @@ type aabbGetShortestAxisSize: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbExpand: proc (self: AABB, toPoint: Vector3): AABB + aabbExpand: proc (self: AABB, toPoint: Vector3): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGrow: proc (self: AABB, by: float32): AABB + aabbGrow: proc (self: AABB, by: float32): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetEndpoint: proc (self: AABB, idx: cint): Vector3 + aabbGetEndpoint: proc (self: AABB, idx: cint): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbOperatorEqual: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1090,36 +1120,36 @@ type locks: 0.} transformNew: proc (dest: var Transform, basis: Basis, origin: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformGetBasis: proc (self: Transform): Basis + transformGetBasis: proc (self: Transform): BasisData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformSetBasis: proc (self: var Transform, basis: Basis) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformGetOrigin: proc (self: Transform): Vector3 + transformGetOrigin: proc (self: Transform): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformSetOrigin: proc (self: var Transform, v: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformAsString: proc (self: Transform): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformInverse: proc (self: Transform): Transform + transformInverse: proc (self: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformAffineInverse: proc (self: Transform): Transform + transformAffineInverse: proc (self: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformOrthonormalized: proc (self: Transform): Transform + transformOrthonormalized: proc (self: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformRotated: proc (self: Transform, axis: Vector3, - phi: float32): Transform + phi: float32): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformScaled: proc (self: Transform, scale: Vector3): Transform + transformScaled: proc (self: Transform, scale: Vector3): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformTranslated: proc (self: Transform, offset: Vector3): Transform + transformTranslated: proc (self: Transform, offset: Vector3): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformLookingAt: proc (self: Transform, target, up: Vector3): Transform + transformLookingAt: proc (self: Transform, target, up: Vector3): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformPlane: proc (self: Transform, plane: Plane): Plane + transformXformPlane: proc (self: Transform, plane: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvPlane: proc (self: Transform, plane: Plane): Plane + transformXformInvPlane: proc (self: Transform, plane: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformNewIdentity: proc (dest: var Transform) @@ -1127,18 +1157,18 @@ type transformOperatorEqual: proc (self, other: Transform): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformOperatorMultiply: proc (self, other: Transform): Transform + transformOperatorMultiply: proc (self, other: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformVector3: proc (self: Transform, v: Vector3): Vector3 + transformXformVector3: proc (self: Transform, v: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvVector3: proc (self: Transform, v: Vector3): Vector3 + transformXformInvVector3: proc (self: Transform, v: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformAABB: proc (self: Transform, v: AABB): AABB + transformXformAABB: proc (self: Transform, v: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvAABB: proc (self: Transform, v: AABB): AABB + transformXformInvAABB: proc (self: Transform, v: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1151,58 +1181,58 @@ type locks: 0.} transform2DAsString: proc (self: Transform2D): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DInverse: proc (self: Transform2D): Transform2D + transform2DInverse: proc (self: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DAffineInverse: proc (self: Transform2D): Transform2D + transform2DAffineInverse: proc (self: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DGetRotation: proc (self: Transform2D): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DGetOrigin: proc (self: Transform2D): Vector2 + transform2DGetOrigin: proc (self: Transform2D): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DGetScale: proc (self: Transform2D): Vector2 + transform2DGetScale: proc (self: Transform2D): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DOrthonormalized: proc (self: Transform2D): Transform2D + transform2DOrthonormalized: proc (self: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DRotated: proc (self: Transform2D, phi: float32): Transform2D + transform2DRotated: proc (self: Transform2D, phi: float32): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DScaled: proc (self: Transform2D, scale: Vector2): Transform2D + transform2DScaled: proc (self: Transform2D, scale: Vector2): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DTranslated: proc (self: Transform2D, offset: Vector2): Transform2D + transform2DTranslated: proc (self: Transform2D, offset: Vector2): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformVector2: proc (self: Transform2D, v: Vector2): Vector2 + transform2DXformVector2: proc (self: Transform2D, v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformInvVector2: proc (self: Transform2D, v: Vector2): Vector2 + transform2DXformInvVector2: proc (self: Transform2D, v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DBasisXformVector2: proc (self: Transform2D, v: Vector2): Vector2 + transform2DBasisXformVector2: proc (self: Transform2D, v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DBasisXformInvVector2: proc (self: Transform2D, - v: Vector2): Vector2 + v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DInterpolateWith: proc (self, other: Transform2D, - t: float32): Transform2D + t: float32): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DOperatorEqual: proc (self, other: Transform2D): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DOperatorMultiply: proc (self, other: Transform2D): Transform2D + transform2DOperatorMultiply: proc (self, other: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DNewIdentity: proc (dest: var Transform2D) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformRect2: proc (self: Transform2D, v: Rect2): Rect2 + transform2DXformRect2: proc (self: Transform2D, v: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformInvRect2: proc (self: Transform2D, v: Rect2): Rect2 + transform2DXformInvRect2: proc (self: Transform2D, v: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1291,25 +1321,25 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsString: proc (self: GodotVariant): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsVector2: proc (self: GodotVariant): Vector2 + variantAsVector2: proc (self: GodotVariant): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRect2: proc (self: GodotVariant): Rect2 + variantAsRect2: proc (self: GodotVariant): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsVector3: proc (self: GodotVariant): Vector3 + variantAsVector3: proc (self: GodotVariant): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsTransform2D: proc (self: GodotVariant): Transform2D + variantAsTransform2D: proc (self: GodotVariant): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsPlane: proc (self: GodotVariant): Plane + variantAsPlane: proc (self: GodotVariant): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsQuat: proc (self: GodotVariant): Quat + variantAsQuat: proc (self: GodotVariant): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsAABB: proc (self: GodotVariant): AABB + variantAsAABB: proc (self: GodotVariant): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsBasis: proc (self: GodotVariant): Basis + variantAsBasis: proc (self: GodotVariant): BasisData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsTransform: proc (self: GodotVariant): Transform + variantAsTransform: proc (self: GodotVariant): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsColor: proc (self: GodotVariant): Color + variantAsColor: proc (self: GodotVariant): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsNodePath: proc (self: GodotVariant): GodotNodePath {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1611,14 +1641,14 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} colorGray*: proc (self: Color): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorInverted*: proc (self: Color): Color + colorInverted*: proc (self: Color): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorContrasted*: proc (self: Color): Color + colorContrasted*: proc (self: Color): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorLinearInterpolate*: proc (self, other: Color, t: float32): Color + colorLinearInterpolate*: proc (self, other: Color, t: float32): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - colorBlend*: proc (self, other: Color): Color + colorBlend*: proc (self, other: Color): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} colorToHtml*: proc (self: Color, withAlpha: bool): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1632,7 +1662,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2AsString*: proc (self: Vector2): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Normalized*: proc (self: Vector2): Vector2 + vector2Normalized*: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2Length*: proc (self: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -1651,57 +1681,57 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2AngleToPoint*: proc (self, to: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2LinearInterpolate*: proc (self, b: Vector2, t: float32): Vector2 + vector2LinearInterpolate*: proc (self, b: Vector2, t: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2CubicInterpolate*: proc (self, b, preA, postB: Vector2, - t: float32): Vector2 + t: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Rotated*: proc (self: Vector2, phi: float32): Vector2 + vector2Rotated*: proc (self: Vector2, phi: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Tangent*: proc (self: Vector2): Vector2 + vector2Tangent*: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Floor*: proc (self: Vector2): Vector2 + vector2Floor*: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Snapped*: proc (self, by: Vector2): Vector2 + vector2Snapped*: proc (self, by: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2Aspect*: proc (self: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2Dot*: proc (self, other: Vector2): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Slide*: proc (self, n: Vector2): Vector2 + vector2Slide*: proc (self, n: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Bounce*: proc (self, n: Vector2): Vector2 + vector2Bounce*: proc (self, n: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Reflect*: proc (self, n: Vector2): Vector2 + vector2Reflect*: proc (self, n: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Abs*: proc (self: Vector2): Vector2 + vector2Abs*: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2Clamped*: proc (self: Vector2, length: float32): Vector2 + vector2Clamped*: proc (self: Vector2, length: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorAdd*: proc (self, other: Vector2): Vector2 + vector2OperatorAdd*: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorSubtract*: proc (self, other: Vector2): Vector2 + vector2OperatorSubtract*: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorMultiplyVector*: proc (self, other: Vector2): Vector2 + vector2OperatorMultiplyVector*: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorMultiplyScalar*: proc (self: Vector2, scalar: float32): Vector2 + vector2OperatorMultiplyScalar*: proc (self: Vector2, scalar: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorDivideVector*: proc (self, other: Vector2): Vector2 + vector2OperatorDivideVector*: proc (self, other: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorDivideScalar*: proc (self: Vector2, scalar: float32): Vector2 + vector2OperatorDivideScalar*: proc (self: Vector2, scalar: float32): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2OperatorEqual*: proc (self, other: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} vector2OperatorLess*: proc (self, other: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - vector2OperatorNeg*: proc (self: Vector2): Vector2 + vector2OperatorNeg*: proc (self: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # Quat API @@ -1732,33 +1762,33 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatLengthSquared*: proc (self: Quat): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatNormalized*: proc (self: Quat): Quat + quatNormalized*: proc (self: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatIsNormalized*: proc (self: Quat): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatInverse*: proc (self: Quat): Quat + quatInverse*: proc (self: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatDot*: proc (self, other: Quat): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatXform*: proc (self: Quat, v: Vector3): Vector3 + quatXform*: proc (self: Quat, v: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSlerp*: proc (self, other: Quat, t: float32): Quat + quatSlerp*: proc (self, other: Quat, t: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatSlerpni*: proc (self, other: Quat, t: float32): Quat + quatSlerpni*: proc (self, other: Quat, t: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatCubicSlerp*: proc (self, other, preA, postB: Quat, t: float32): Quat + quatCubicSlerp*: proc (self, other, preA, postB: Quat, t: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorMultiply*: proc (self: Quat, b: float32): Quat + quatOperatorMultiply*: proc (self: Quat, b: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorAdd*: proc (self, other: Quat): Quat + quatOperatorAdd*: proc (self, other: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorSubtract*: proc (self, other: Quat): Quat + quatOperatorSubtract*: proc (self, other: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorDivide*: proc (self: Quat, divider: float32): Quat + quatOperatorDivide*: proc (self: Quat, divider: float32): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} quatOperatorEqual*: proc (self, other: Quat): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - quatOperatorNeg*: proc (self: Quat): Quat + quatOperatorNeg*: proc (self: Quat): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} # PoolByteArray API @@ -1977,7 +2007,7 @@ type poolVector2ArraySet*: proc (self: var GodotPoolVector2Array, idx: cint, data: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector2ArrayGet*: proc (self: GodotPoolVector2Array, idx: cint): Vector2 + poolVector2ArrayGet*: proc (self: GodotPoolVector2Array, idx: cint): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolVector2ArraySize*: proc (self: GodotPoolVector2Array): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2026,7 +2056,7 @@ type poolVector3ArraySet*: proc (self: var GodotPoolVector3Array, idx: cint, data: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolVector3ArrayGet*: proc (self: GodotPoolVector3Array, idx: cint): Vector3 + poolVector3ArrayGet*: proc (self: GodotPoolVector3Array, idx: cint): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolVector3ArraySize*: proc (self: GodotPoolVector3Array): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2071,7 +2101,7 @@ type poolColorArraySet*: proc (self: var GodotPoolColorArray, idx: cint, data: Color) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolColorArrayGet*: proc (self: GodotPoolColorArray, idx: cint): Color + poolColorArrayGet*: proc (self: GodotPoolColorArray, idx: cint): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} poolColorArraySize*: proc (self: GodotPoolColorArray): cint {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2378,11 +2408,11 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeAsString*: proc (self: Plane): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeNormalized*: proc (self: Plane): Plane + planeNormalized*: proc (self: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeCenter*: proc (self: Plane): Vector3 + planeCenter*: proc (self: Plane): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetAnyPoint*: proc (self: Plane): Vector3 + planeGetAnyPoint*: proc (self: Plane): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeIsPointOver*: proc (self: Plane, point: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2390,7 +2420,7 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeHasPoint*: proc (self: Plane, point: Vector3, epsilon: float32): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeProject*: proc (self: Plane, point: Vector3): Vector3 + planeProject*: proc (self: Plane, point: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeIntersect3*: proc (self: Plane, dest: var Vector3, b, c: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2401,13 +2431,13 @@ type segmentBegin, segmentEnd: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeOperatorNeg*: proc (self: Plane): Plane + planeOperatorNeg*: proc (self: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeOperatorEqual*: proc (self, other: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeSetNormal*: proc (self: var Plane, normal: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - planeGetNormal*: proc (self: Plane): Vector3 + planeGetNormal*: proc (self: Plane): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} planeGetD*: proc (self: Plane): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2430,21 +2460,21 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2HasNoArea*: proc (self: Rect2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Clip*: proc (self, other: Rect2): Rect2 + rect2Clip*: proc (self, other: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Merge*: proc (self, other: Rect2): Rect2 + rect2Merge*: proc (self, other: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2HasPoint*: proc (self: Rect2, point: Vector2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Grow*: proc (self: Rect2, by: float32): Rect2 + rect2Grow*: proc (self: Rect2, by: float32): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2Expand*: proc (self: Rect2, to: Vector2): Rect2 + rect2Expand*: proc (self: Rect2, to: Vector2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2OperatorEqual*: proc (self, other: Rect2): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetPosition*: proc (self: Rect2): Vector2 + rect2GetPosition*: proc (self: Rect2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - rect2GetSize*: proc (self: Rect2): Vector2 + rect2GetSize*: proc (self: Rect2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} rect2SetPosition*: proc (self: var Rect2, pos: Vector2) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2454,11 +2484,11 @@ type # AABB API aabbNew*: proc (dest: var AABB, pos, size: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetPosition*: proc (self: AABB): Vector3 + aabbGetPosition*: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbSetPosition*: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetSize*: proc (self: AABB): Vector3 + aabbGetSize*: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbSetSize*: proc (self: var AABB, pos: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2474,9 +2504,9 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbEncloses*: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbMerge*: proc (self, other: AABB): AABB + aabbMerge*: proc (self, other: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbIntersection*: proc (self, other: AABB): AABB + aabbIntersection*: proc (self, other: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbIntersectsPlane*: proc (self: AABB, plane: Plane): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2485,9 +2515,9 @@ type locks: 0.} aabbHasPoint*: proc (self: AABB, point: Vector3): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetSupport*: proc (self: AABB, dir: Vector3): Vector3 + aabbGetSupport*: proc (self: AABB, dir: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetLongestAxis*: proc (self: AABB): Vector3 + aabbGetLongestAxis*: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbGetLongestAxisIndex*: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], @@ -2495,7 +2525,7 @@ type aabbGetLongestAxisSize*: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetShortestAxis*: proc (self: AABB): Vector3 + aabbGetShortestAxis*: proc (self: AABB): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbGetShortestAxisIndex*: proc (self: AABB): cint {.noconv, raises: [], gcsafe, tags: [], @@ -2503,11 +2533,11 @@ type aabbGetShortestAxisSize*: proc (self: AABB): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbExpand*: proc (self: AABB, toPoint: Vector3): AABB + aabbExpand*: proc (self: AABB, toPoint: Vector3): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGrow*: proc (self: AABB, by: float32): AABB + aabbGrow*: proc (self: AABB, by: float32): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - aabbGetEndpoint*: proc (self: AABB, idx: cint): Vector3 + aabbGetEndpoint*: proc (self: AABB, idx: cint): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} aabbOperatorEqual*: proc (self, other: AABB): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2531,36 +2561,36 @@ type locks: 0.} transformNew*: proc (dest: var Transform, basis: Basis, origin: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformGetBasis*: proc (self: Transform): Basis + transformGetBasis*: proc (self: Transform): BasisData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformSetBasis*: proc (self: var Transform, basis: Basis) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformGetOrigin*: proc (self: Transform): Vector3 + transformGetOrigin*: proc (self: Transform): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformSetOrigin*: proc (self: var Transform, v: Vector3) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformAsString*: proc (self: Transform): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformInverse*: proc (self: Transform): Transform + transformInverse*: proc (self: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformAffineInverse*: proc (self: Transform): Transform + transformAffineInverse*: proc (self: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformOrthonormalized*: proc (self: Transform): Transform + transformOrthonormalized*: proc (self: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformRotated*: proc (self: Transform, axis: Vector3, - phi: float32): Transform + phi: float32): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformScaled*: proc (self: Transform, scale: Vector3): Transform + transformScaled*: proc (self: Transform, scale: Vector3): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformTranslated*: proc (self: Transform, offset: Vector3): Transform + transformTranslated*: proc (self: Transform, offset: Vector3): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformLookingAt*: proc (self: Transform, target, up: Vector3): Transform + transformLookingAt*: proc (self: Transform, target, up: Vector3): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformPlane*: proc (self: Transform, plane: Plane): Plane + transformXformPlane*: proc (self: Transform, plane: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvPlane*: proc (self: Transform, plane: Plane): Plane + transformXformInvPlane*: proc (self: Transform, plane: Plane): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transformNewIdentity*: proc (dest: var Transform) @@ -2568,18 +2598,18 @@ type transformOperatorEqual*: proc (self, other: Transform): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformOperatorMultiply*: proc (self, other: Transform): Transform + transformOperatorMultiply*: proc (self, other: Transform): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformVector3*: proc (self: Transform, v: Vector3): Vector3 + transformXformVector3*: proc (self: Transform, v: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3 + transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformAABB*: proc (self: Transform, v: AABB): AABB + transformXformAABB*: proc (self: Transform, v: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transformXformInvAABB*: proc (self: Transform, v: AABB): AABB + transformXformInvAABB*: proc (self: Transform, v: AABB): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2592,58 +2622,58 @@ type locks: 0.} transform2DAsString*: proc (self: Transform2D): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DInverse*: proc (self: Transform2D): Transform2D + transform2DInverse*: proc (self: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DAffineInverse*: proc (self: Transform2D): Transform2D + transform2DAffineInverse*: proc (self: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DGetRotation*: proc (self: Transform2D): float32 {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DGetOrigin*: proc (self: Transform2D): Vector2 + transform2DGetOrigin*: proc (self: Transform2D): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DGetScale*: proc (self: Transform2D): Vector2 + transform2DGetScale*: proc (self: Transform2D): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DOrthonormalized*: proc (self: Transform2D): Transform2D + transform2DOrthonormalized*: proc (self: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DRotated*: proc (self: Transform2D, phi: float32): Transform2D + transform2DRotated*: proc (self: Transform2D, phi: float32): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DScaled*: proc (self: Transform2D, scale: Vector2): Transform2D + transform2DScaled*: proc (self: Transform2D, scale: Vector2): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DTranslated*: proc (self: Transform2D, offset: Vector2): Transform2D + transform2DTranslated*: proc (self: Transform2D, offset: Vector2): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 + transform2DXformVector2*: proc (self: Transform2D, v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformInvVector2*: proc (self: Transform2D, v: Vector2): Vector2 + transform2DXformInvVector2*: proc (self: Transform2D, v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DBasisXformVector2*: proc (self: Transform2D, v: Vector2): Vector2 + transform2DBasisXformVector2*: proc (self: Transform2D, v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DBasisXformInvVector2*: proc (self: Transform2D, - v: Vector2): Vector2 + v: Vector2): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DInterpolateWith*: proc (self, other: Transform2D, - t: float32): Transform2D + t: float32): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DOperatorEqual*: proc (self, other: Transform2D): bool {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DOperatorMultiply*: proc (self, other: Transform2D): Transform2D + transform2DOperatorMultiply*: proc (self, other: Transform2D): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} transform2DNewIdentity*: proc (dest: var Transform2D) {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformRect2*: proc (self: Transform2D, v: Rect2): Rect2 + transform2DXformRect2*: proc (self: Transform2D, v: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - transform2DXformInvRect2*: proc (self: Transform2D, v: Rect2): Rect2 + transform2DXformInvRect2*: proc (self: Transform2D, v: Rect2): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2732,25 +2762,25 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsString*: proc (self: GodotVariant): GodotString {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsVector2*: proc (self: GodotVariant): Vector2 + variantAsVector2*: proc (self: GodotVariant): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsRect2*: proc (self: GodotVariant): Rect2 + variantAsRect2*: proc (self: GodotVariant): Rect2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsVector3*: proc (self: GodotVariant): Vector3 + variantAsVector3*: proc (self: GodotVariant): Vector3Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsTransform2D*: proc (self: GodotVariant): Transform2D + variantAsTransform2D*: proc (self: GodotVariant): Transform2DData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsPlane*: proc (self: GodotVariant): Plane + variantAsPlane*: proc (self: GodotVariant): PlaneData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsQuat*: proc (self: GodotVariant): Quat + variantAsQuat*: proc (self: GodotVariant): QuatData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsAABB*: proc (self: GodotVariant): AABB + variantAsAABB*: proc (self: GodotVariant): AABBData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsBasis*: proc (self: GodotVariant): Basis + variantAsBasis*: proc (self: GodotVariant): BasisData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsTransform*: proc (self: GodotVariant): Transform + variantAsTransform*: proc (self: GodotVariant): TransformData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - variantAsColor*: proc (self: GodotVariant): Color + variantAsColor*: proc (self: GodotVariant): ColorData {.noconv, raises: [], gcsafe, tags: [], locks: 0.} variantAsNodePath*: proc (self: GodotVariant): GodotNodePath {.noconv, raises: [], gcsafe, tags: [], locks: 0.} @@ -2898,6 +2928,38 @@ type {.noconv, raises: [], gcsafe, tags: [], locks: 0.} +{.push stackTrace: off.} +proc toColor*(val: ColorData): Color {.inline, noinit.} = + cast[Color](val) + +proc toVector3*(val: Vector3Data): Vector3 {.inline, noinit.} = + cast[Vector3](val) + +proc toVector2*(val: Vector2Data): Vector2 {.inline, noinit.} = + cast[Vector2](val) + +proc toPlane*(val: PlaneData): Plane {.inline, noinit.} = + cast[Plane](val) + +proc toBasis*(val: BasisData): Basis {.inline, noinit.} = + cast[Basis](val) + +proc toQuat*(val: QuatData): Quat {.inline, noinit.} = + cast[Quat](val) + +proc toAABB*(val: AABBData): AABB {.inline, noinit.} = + cast[AABB](val) + +proc toRect2*(val: Rect2Data): Rect2 {.inline, noinit.} = + cast[Rect2](val) + +proc toTransform2D*(val: Transform2DData): Transform2D {.inline, noinit.} = + cast[Transform2D](val) + +proc toTransform*(val: TransformData): Transform {.inline, noinit.} = + cast[Transform](val) +{.pop.} + macro assign(dest, src: typed, values: untyped): typed = result = newStmtList() for val in values: diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index e03e1ff..5fe9419 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -45,7 +45,15 @@ template genPoolArrayAPI(ArrayT, initIdent, DataT, getGDNativeAPI().setProc(self, idx, data) proc `[]`*(self: ArrayT; idx: cint): DataT {.inline.} = - getGDNativeAPI().getProc(self, idx) + let data = getGDNativeAPI().getProc(self, idx) + when DataT is Color: + data.toColor() + elif DataT is Vector2: + data.toVector2() + elif DataT is Vector3: + data.toVector3() + else: + data proc len*(self: ArrayT): cint {.inline.} = getGDNativeAPI().sizeProc(self) diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 3f961ca..fec75cd 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -121,34 +121,34 @@ proc asGodotString*(self: GodotVariant): GodotString {.inline.} = getGDNativeAPI().variantAsString(self) proc asVector2*(self: GodotVariant): Vector2 {.inline.} = - getGDNativeAPI().variantAsVector2(self) + getGDNativeAPI().variantAsVector2(self).toVector2() proc asRect2*(self: GodotVariant): Rect2 {.inline.} = - getGDNativeAPI().variantAsRect2(self) + getGDNativeAPI().variantAsRect2(self).toRect2() proc asVector3*(self: GodotVariant): Vector3 {.inline.} = - getGDNativeAPI().variantAsVector3(self) + getGDNativeAPI().variantAsVector3(self).toVector3() proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} = - getGDNativeAPI().variantAsTransform2D(self) + getGDNativeAPI().variantAsTransform2D(self).toTransform2D() proc asPlane*(self: GodotVariant): Plane {.inline.} = - getGDNativeAPI().variantAsPlane(self) + getGDNativeAPI().variantAsPlane(self).toPlane() proc asQuat*(self: GodotVariant): Quat {.inline.} = - getGDNativeAPI().variantAsQuat(self) + getGDNativeAPI().variantAsQuat(self).toQuat() proc asAABB*(self: GodotVariant): AABB {.inline.} = - getGDNativeAPI().variantAsAABB(self) + getGDNativeAPI().variantAsAABB(self).toAABB() proc asBasis*(self: GodotVariant): Basis {.inline.} = - getGDNativeAPI().variantAsBasis(self) + getGDNativeAPI().variantAsBasis(self).toBasis() proc asTransform*(self: GodotVariant): Transform {.inline.} = - getGDNativeAPI().variantAsTransform(self) + getGDNativeAPI().variantAsTransform(self).toTransform() proc asColor*(self: GodotVariant): Color {.inline.} = - getGDNativeAPI().variantAsColor(self) + getGDNativeAPI().variantAsColor(self).toColor() proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} = getGDNativeAPI().variantAsNodePath(self) From db4bb91765b5502d9f660eaef8c59583c6b3756f Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Tue, 9 Jul 2019 13:48:54 +0700 Subject: [PATCH 137/160] Fix editor crash in multithreaded mode --- godot.nimble | 2 +- godot/nim/godotnim.nim | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index 8e4c8c0..6964c83 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.18" +version = "0.7.19" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 665b715..979613f 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -867,7 +867,8 @@ proc godot_gdnative_init(options: ptr GDNativeInitOptions) {. proc godot_gdnative_terminate(options: ptr GDNativeTerminateOptions) {. cdecl, exportc, dynlib.} = - deallocHeap(runFinalizers = not options[].inEditor, allowGcAfterwards = false) + if not options[].inEditor or not compileOption("threads"): + deallocHeap(runFinalizers = not options[].inEditor, allowGcAfterwards = false) const nimGcStepLengthUs {.intdefine.} = 2000 From f45281f5a0cdb9e1de482a047aa49156fbc8f92f Mon Sep 17 00:00:00 2001 From: Konstantin Zaitsev Date: Thu, 12 Sep 2019 14:50:02 +0700 Subject: [PATCH 138/160] Fix possible double free memory on exit --- godot.nimble | 2 +- godot/nim/godotnim.nim | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/godot.nimble b/godot.nimble index 6964c83..66794fc 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.19" +version = "0.7.20" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 979613f..d3fa9cf 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -189,8 +189,8 @@ proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) = if obj.godotObject.isNil or obj.isNative: return # important to set it before so that ``unreference`` is aware obj.isFinalized = true - if obj.isRef and obj.godotObject.unreference() or - not obj.linkedObject.isNil: + if (obj.isRef or not obj.linkedObject.isNil and obj.linkedObject.isRef) and + obj.godotObject.unreference(): obj.deinit() macro baseNativeType(T: typedesc): cstring = From 3a935b93087682867f9e5278fbd32c781bbda923 Mon Sep 17 00:00:00 2001 From: Fabian Keller Date: Sun, 30 Dec 2018 12:40:10 +0100 Subject: [PATCH 139/160] attempt to make 0.19 compatible workaround for nim/macro/typedesc issue work-around for nim-lang/Nim#7375 fixed more isNil usages fixed new name of setStackBottom --- docs/docbuild.nim | 4 +- godot/core/variants.nim | 9 ++-- godot/godotapigen.nim | 95 ++++++++++++++++++--------------- godot/internal/godotstrings.nim | 5 +- godot/nim/godotmacros.nim | 41 +++++++------- godot/nim/godotnim.nim | 40 ++++++-------- 6 files changed, 94 insertions(+), 100 deletions(-) diff --git a/docs/docbuild.nim b/docs/docbuild.nim index 10823a5..477c45b 100644 --- a/docs/docbuild.nim +++ b/docs/docbuild.nim @@ -71,7 +71,7 @@ proc fixupHrefs(file: string) = proc getGitHash(): string = result = execProcess("git rev-parse HEAD") - if not result.isNil and result.len > 0: + if result.len > 0: result = result.replace("\L", "").replace("\r", "") proc buildDocs*(outDir, godotNimDir, godotBin: string) = @@ -112,7 +112,7 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) = var gitHash: string withDir(godotBinAbs.parentDir()): gitHash = getGitHash() - if gitHash.isNil or gitHash.len == 0: + if gitHash.len == 0: raise newException(Exception, "Godot executable is not under Git repository") diff --git a/godot/core/variants.nim b/godot/core/variants.nim index ace8aac..8c2488d 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -73,12 +73,9 @@ proc newVariant*(r: cdouble): Variant {.inline.} = proc newVariant*(s: string): Variant {.inline.} = new(result, variantFinalizer) - if s.isNil: - initGodotVariant(result.godotVariant) - else: - var godotStr = s.toGodotString() - initGodotVariant(result.godotVariant, godotStr) - godotStr.deinit() + var godotStr = s.toGodotString() + initGodotVariant(result.godotVariant, godotStr) + godotStr.deinit() import basis, nodepaths import planes, quats, rect2, aabb, rids diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 876e770..5ec1c73 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -1,9 +1,15 @@ # Copyright 2018 Xored Software, Inc. -import streams, json, os, strutils, times, sets, tables +import streams, json, os, strutils, times, sets, tables, options import sequtils, algorithm import compiler.ast, compiler.renderer, compiler.idents, compiler.astalgo +when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0): + var gic* = newIdentCache() + + proc getIdent(ident: string): PIdent = + getIdent(gic, ident) + proc ident(ident: string): PNode = result = newNode(nkIdent) result.ident = getIdent(ident) @@ -139,19 +145,19 @@ proc findCommonRoot(typeRegistry: Table[string, GodotType], var idx = 0 while true: - var curType: string + var curType = none(string) var allEqual = true for chain in chains: if idx >= chain.len: allEqual = false break - if curType.isNil: - curType = chain[idx] - elif curType != chain[idx]: + if curType.isNone: + curType = some(chain[idx]) + elif curType.get != chain[idx]: allEqual = false break if allEqual: - result = curType + result = curType.get else: break inc idx @@ -224,7 +230,7 @@ proc newRefTypeNode(typeSection: PNode, typ, base, doc: string, inherit.add(ident(base)) objTy.add(inherit) - if not doc.isNil: + if doc.len > 0: let recList = newNode(nkRecList) let docNode = newNode(nkCommentStmt) docNode.comment = doc @@ -275,7 +281,7 @@ type godotName: string typ: GodotType args: seq[MethodArg] - returnType: string + returnType: Option[string] isVirtual: bool isBase: bool isDiscardable: bool @@ -428,7 +434,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newCStringLit(meth.godotName)) ) let vars = newNode(nkVarSection) - var varargsName: string + var varargsName = none(string) var isVarargs: bool var staticArgsLen: int var argLenNode = newIntLit(0) @@ -436,7 +442,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if meth.args.len > 0: for idx, arg in meth.args: if arg.kind == ArgKind.VarArgs: - varargsName = arg.name + varargsName = some(arg.name) isVarargs = true vars.add(newIdentDefs(ident("callError"), ident("VariantCallError"))) elif arg.kind == ArgKind.Bound: @@ -450,13 +456,13 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ident("array"), ident("MAX_ARG_COUNT"), if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) else: ident("pointer")))) - staticArgsLen = if varargsName.isNil: meth.args.len + staticArgsLen = if varargsName.isSome: meth.args.len else: meth.args.len - 1 - if not varargsName.isNil: + if varargsName.isSome: argLenNode = newCall("cint", infix(newIntLit(staticArgsLen), ident("+"), - newDotExpr(ident(varargsName), ident("len")))) + newDotExpr(ident(varargsName.get), ident("len")))) argsAlloc.add(newCall("godotAlloc", newCall("cint", infix( newCall("sizeof", ident("Variant")), ident("*"), newNode(nkPar).addChain(argLenNode)))) @@ -477,12 +483,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], else: ident(arg.name) if arg.kind == ArgKind.VarArgs: argName = newNode(nkBracketExpr).addChain( - ident(varargsName), + ident(varargsName.get), infix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) let argIdx = if arg.kind == ArgKind.VarArgs: ident("idx") else: newIntLit(idx) let isStandardType = arg.typ in standardTypes let isWrappedType = arg.typ in wrapperTypes - let convArg = if not varargsName.isNil: + let convArg = if varargsName.isSome: getInternalPtr(newCall("toVariant", argName), "Variant") elif isWrappedType: getInternalPtr(argName, arg.typ) elif isStandardType: newCall("unsafeAddr", argName) @@ -493,7 +499,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], raise newException(ValueError, "Non-standard type $# for varargs params of method $# of type $#" % [arg.typ, meth.godotName, meth.typ.godotName]) - if not isStandardType and varargsName.isNil: + if not isStandardType and varargsName.isNone: if arg.typ == "string": argConversions.add(newNode(nkVarSection).addChain( newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), @@ -560,31 +566,32 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var isStringRet: bool var isWrapperRet: bool let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName) - if not meth.returnType.isNil and not isVarargs: + if meth.returnType.isSome and not isVarargs: + let returnType = meth.returnType.get var addrToAssign = newCall("addr", retValIdent) - if meth.returnType in smallIntTypes: + if returnType in smallIntTypes: isConversionRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("int64"), ))) - elif meth.returnType in float32Types: + elif returnType in float32Types: isConversionRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("float64"), ))) - elif meth.returnType in wrapperTypes: + elif returnType in wrapperTypes: isWrapperRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, ident("Godot" & meth.returnType), + retValIdent, ident("Godot" & returnType), ))) - elif meth.returnType in standardTypes: + elif returnType in standardTypes: addrToAssign = newCall("addr", ident("result")) - elif meth.returnType == "string": + elif returnType == "string": isStringRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("GodotString"), ))) - elif meth.returnType != "void": + elif returnType != "void": isObjRet = true body.add(newNode(nkVarSection).addChain(newIdentDefs( retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")), @@ -594,7 +601,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if not isVarargs: body.add(theCall) else: - if not meth.returnType.isNil: + if meth.returnType.isSome: isVariantRet = true let callStmt = newNode(nkLetSection).addChain( newIdentDefs( @@ -603,14 +610,14 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newNode(nkEmpty), theCall)) body.add(callStmt) - if varargsName.isNil: + if varargsName.isNone: for idx, arg in meth.args: if arg.typ == "string": body.add(newCall("deinit", ident("argToPassToGodot" & $idx))) - if meth.args.len > 0 and not varargsName.isNil: + if meth.args.len > 0 and varargsName.isSome: body.add(freeCall) - if not varargsName.isNil: + if varargsName.isSome: let errCheck = newIfStmt( infix(newDotExpr(ident("callError"), ident("error")), ident("!="), newDotExpr(ident("VariantCallErrorType"), ident("OK"))), @@ -638,11 +645,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], elif isConversionRet: body.add(newNode(nkAsgn).addChain( ident("result"), - newCall(meth.returnType, retValIdent))) + newCall(meth.returnType.get, retValIdent))) elif isWrapperRet: body.add(newNode(nkAsgn).addChain( ident("result"), - newCall("new" & meth.returnType, retValIdent))) + newCall("new" & meth.returnType.get, retValIdent))) elif isObjRet: body.add(newNode(nkAsgn).addChain(ident("result"), newCall(newBracketExpr(ident("asNimGodotObject"), @@ -655,8 +662,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], let procType = if meth.isVirtual: nkMethodDef else: nkProcDef var params = newSeqOfCap[PNode](meth.args.len + 2) - if not meth.returnType.isNil: - params.add(ident(meth.returnType)) + if meth.returnType.isSome: + params.add(ident(meth.returnType.get)) else: params.add(newNode(nkEmpty)) if not meth.typ.isSingleton: @@ -684,7 +691,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if meth.isVirtual and meth.isBase and meth.typ.name != "PhysicsBody": # Nim doesn't like `base` on PhysicsBody methods - wtf pragma.add(ident("base")) - if meth.isDiscardable and not meth.returnType.isNil: + if meth.isDiscardable and meth.returnType.isSome: pragma.add(ident("discardable")) procDecl.sons[4] = pragma tree.add(procDecl) @@ -729,8 +736,8 @@ proc getMethodInfo(methodObj: JsonNode, types: Table[string, GodotType], nimName = nimName & "Impl" let returnType = if methodObj["return_type"].str != "void": - toNimType(types, methodObj["return_type"].str) - else: nil + some(toNimType(types, methodObj["return_type"].str)) + else: none(string) const discardableMethods = toSet(["emit_signal"]) result = MethodInfo( name: ident(nimName), @@ -764,13 +771,13 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode, let getter = findMethod(obj, propertyObj["getter"].str) let nimType = if getter.isNil: toNimType(types, propertyObj["type"].str) - else: getMethodInfo(getter, types, typ).returnType + else: getMethodInfo(getter, types, typ).returnType.get("void") let getterInfo = MethodInfo( name: getterName, typ: typ, godotName: propertyObj["getter"].str, - args: @[], - returnType: nimType + args: newSeq[MethodArg](), + returnType: some(nimType) ) let setterInfo = MethodInfo( name: setterName, @@ -779,10 +786,12 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode, args: @[MethodArg(name: "val", typ: nimType)] ) if "index" in propertyObj and propertyObj["index"] != newJInt(-1): - getterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]), - typ: "int", kind: ArgKind.Bound)] & getterInfo.args - setterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]), - typ: "int", kind: ArgKind.Bound)] & setterInfo.args + getterInfo.args = + @[MethodArg(defaultVal: newJString($propertyObj["index"]), + typ: "int", kind: ArgKind.Bound)] & getterInfo.args + setterInfo.args = + @[MethodArg(defaultVal: newJString($propertyObj["index"]), + typ: "int", kind: ArgKind.Bound)] & setterInfo.args generateMethod(tree, methodBindRegistry, getterInfo, withImplementation) generateMethod(tree, methodBindRegistry, setterInfo, withImplementation) @@ -920,7 +929,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) = let className = godotClassName.replace("_", "") var baseClassName = obj["base_class"].str baseClassName = toNimType(baseClassName.replace("_", "")) - if baseClassName.isNil or baseClassName.len == 0: + if baseClassName.len == 0: baseClassName = "NimGodotObject" var doc = "" for attr in classAttributes: diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index be18df0..18bcf63 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -38,10 +38,7 @@ proc `$`*(self: GodotString): string = proc toGodotString*(s: string): GodotString {.inline.} = ## Converts the Nim string into ``GodotString`` - if s.isNil: - initGodotString(result) - else: - initGodotString(result, cstring(s), cint(s.len + 1)) + initGodotString(result, cstring(s), cint(s.len + 1)) proc toGodotString*(s: cstring): GodotString {.inline.} = ## Converts the cstring into ``GodotString`` diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 352925a..052b2fc 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -1,6 +1,6 @@ # Copyright 2018 Xored Software, Inc. -import macros, tables, typetraits +import macros, tables, typetraits, strutils, sets, sequtils, options import godotinternal, internal.godotvariants import godotnim, core.variants @@ -10,8 +10,8 @@ type typ: NimNode defaultValue: NimNode isNoGodot: bool - hint: string - hintStr: string + hint: Option[string] + hintStr: Option[string] usage: NimNode isExported: bool @@ -111,12 +111,12 @@ proc removePragma(statement: NimNode, pname: string): bool = return true proc removeStrPragma(statement: NimNode, - pname: string): string {.compileTime.} = + pname: string): Option[string] {.compileTime.} = ## Removes the pragma from the node and returns value of the pragma ## Works for routine nodes or nnkPragmaExpr let node = removePragmaNode(statement, pname) - result = if node.isNil: nil - else: $node + result = if node.isNil: none(string) + else: some($node) proc isExported(node: NimNode): bool {.compileTime.} = if node.kind == nnkPragmaExpr: @@ -197,7 +197,7 @@ proc parseType(definition, callSite: NimNode): ObjectDecl = parseError(option, "valid type specifier expected") result.isTool = isTool - if result.parentName.isNil: result.parentName = "Object" + if result.parentName == "": result.parentName = "Object" for statement in body: case statement.kind: of nnkVarSection: @@ -424,9 +424,6 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, unsafeAddr attr, setFunc, getFunc) hintStrGodot.deinit() -static: - import strutils, sets, sequtils - proc toGodotStyle(s: string): string {.compileTime.} = result = newStringOfCap(s.len + 10) for c in s: @@ -447,7 +444,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = let objTy = newNimNode(nnkObjectTy) typeDef.add(newNimNode(nnkRefTy).add(objTy)) objTy.add(newEmptyNode()) - if obj.parentName.isNil: + if obj.parentName == "": objTy.add(newEmptyNode()) else: objTy.add(newNimNode(nnkOfInherit).add(ident(obj.parentName))) @@ -506,23 +503,25 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = result.add(meth.nimNode) # Register Godot object - let parentName = if obj.parentName.isNil: newStrLitNode("Object") + let parentName = if obj.parentName == "": newStrLitNode("Object") else: newStrLitNode(obj.parentName) let classNameLit = newStrLitNode(obj.name) let classNameIdent = ident(obj.name) - let isRef: bool = if obj.parentName.isNil: false + let isRef: bool = if obj.parentName == "": false else: obj.parentName in refClasses + # Wrapping bools with a newLit is required as a temporary workaround for + # https://github.com/nim-lang/Nim/issues/7375 result.add(getAst( - registerGodotClass(classNameIdent, classNameLit, isRef, parentName, - genSym(nskProc, "createFunc"), obj.isTool))) + registerGodotClass(classNameIdent, classNameLit, newLit(isRef), parentName, + genSym(nskProc, "createFunc"), newLit(obj.isTool)))) # Register fields (properties) for field in obj.fields: if field.isNoGodot: continue - let hintStr = if field.hintStr.isNil: "NIM" - else: field.hintStr - let hint = if field.hint.isNil: "NIM" - else: field.hint + let hintStr = if field.hintStr.isNone: "NIM" + else: field.hintStr.get + let hint = if field.hint.isNone: "NIM" + else: field.hint.get let usage = if field.usage.isNil: newLit(ord(GodotPropertyUsage.Default) or @@ -546,7 +545,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = methodNameLit, minArgs, maxArgs, argTypes, methFuncIdent, hasReturnValue) = {.emit: """/*TYPESECTION*/ -N_NOINLINE(void, setStackBottom)(void* thestackbottom); +N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); """.} proc methFuncIdent(obj: ptr GodotObject, methodData: pointer, userData: pointer, numArgs: cint, @@ -554,7 +553,7 @@ N_NOINLINE(void, setStackBottom)(void* thestackbottom); GodotVariant {.noconv.} = var stackBottom {.volatile.}: pointer {.emit: """ - setStackBottom((void*)(&`stackBottom`)); + nimGC_setStackBottom((void*)(&`stackBottom`)); """.} let self = cast[classNameIdent](userData) const isStaticCall = methodNameLit == cstring"_ready" or diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index d3fa9cf..41ef51e 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,6 +1,6 @@ # Copyright 2018 Xored Software, Inc. -import tables, typetraits, macros, unicode +import tables, typetraits, macros, unicode, strutils, sets import gdnativeapi import core.godotcoretypes, core.godotbase import core.vector2, core.rect2, @@ -101,8 +101,6 @@ var classRegistryStatic* {.compileTime.}: TableRef[FNV1Hash, ObjectInfo] static: classRegistryStatic = newTable[FNV1Hash, ObjectInfo]() -static: - import sets, strutils var nativeClasses {.compileTime.} = newSeq[string]() var refClasses* {.compileTime.} = newSeq[string]() @@ -204,7 +202,7 @@ macro baseNativeType(T: typedesc): cstring = if typeName == "NimGodotObject": break t = getType(t[1][1]) - if baseT.isNil: + if baseT == "": result = newNilLit() else: let rStr = newNimNode(nnkRStrLit) @@ -345,26 +343,20 @@ proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) result.strVal = s -static: - import strutils - -macro toGodotName(T: typedesc): string = - var godotName: string +proc toGodotName(T: typedesc): string = if T is GodotString or T is string: - godotName = "String" + "String" elif T is SomeFloat: - godotName = "float" + "float" elif T is SomeUnsignedInt or T is SomeSignedInt: - godotName = "int" - if godotName.isNil or godotName.len == 0: + "int" + else: let nameStr = (($T.getType()[1][1].symbol).split(':')[0]) - godotName = case nameStr: - of "File", "Directory", "Thread", "Mutex", "Semaphore": - "_" & nameStr - else: - nameStr - - result = newLit(godotName) + case nameStr: + of "File", "Directory", "Thread", "Mutex", "Semaphore": + "_" & nameStr + else: + nameStr macro asCString(s: static[string]): cstring = result = newNimNode(nnkCallStrLit).add( @@ -717,7 +709,7 @@ proc fromVariant*(s: var string, val: Variant): ConversionResult = if val.getType() == VariantType.String: s = val.asString() elif val.getType() == VariantType.Nil: - s = nil + s = "" else: result = ConversionResult.TypeError @@ -839,7 +831,7 @@ proc fromVariant*[T: Table or TableRef or OrderedTable or OrderedTableRef](t: va {.emit: """/*TYPESECTION*/ N_LIB_EXPORT N_CDECL(void, NimMain)(void); -N_NOINLINE(void, setStackBottom)(void* thestackbottom); +N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); """.} var nativeLibHandle: pointer @@ -855,7 +847,7 @@ proc godot_nativescript_init(handle: pointer) {. var stackBottom {.volatile.}: pointer {.emit: """ NimMain(); - setStackBottom((void*)(&`stackBottom`)); + nimGC_setStackBottom((void*)(&`stackBottom`)); """.} GC_fullCollect() GC_disable() @@ -893,7 +885,7 @@ proc registerFrameCallback*(cb: proc () {.closure.}) = proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = var stackBottom {.volatile.}: pointer {.emit: """ - setStackBottom((void*)(&`stackBottom`)); + nimGC_setStackBottom((void*)(&`stackBottom`)); """.} for cb in idleCallbacks: cb() From 34fda99def2cdae837b4bccc153c17e9a86de98e Mon Sep 17 00:00:00 2001 From: zetashift Date: Fri, 1 Mar 2019 02:18:00 +0100 Subject: [PATCH 140/160] Small changes to add 0.18.0 compatibility Change toGodotName back to macro because that got fixed in devel change isSome to isNone in godotapigen --- godot/godotapigen.nim | 2 +- godot/nim/godotmacros.nim | 16 +++++++++++----- godot/nim/godotnim.nim | 30 +++++++++++++++++++++--------- 3 files changed, 33 insertions(+), 15 deletions(-) diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 5ec1c73..71a52ff 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -456,7 +456,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ident("array"), ident("MAX_ARG_COUNT"), if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) else: ident("pointer")))) - staticArgsLen = if varargsName.isSome: meth.args.len + staticArgsLen = if varargsName.isNone: meth.args.len else: meth.args.len - 1 if varargsName.isSome: argLenNode = newCall("cint", diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 052b2fc..4389859 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -197,7 +197,7 @@ proc parseType(definition, callSite: NimNode): ObjectDecl = parseError(option, "valid type specifier expected") result.isTool = isTool - if result.parentName == "": result.parentName = "Object" + if result.parentName.len == 0: result.parentName = "Object" for statement in body: case statement.kind: of nnkVarSection: @@ -444,7 +444,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = let objTy = newNimNode(nnkObjectTy) typeDef.add(newNimNode(nnkRefTy).add(objTy)) objTy.add(newEmptyNode()) - if obj.parentName == "": + if obj.parentName.len == 0: objTy.add(newEmptyNode()) else: objTy.add(newNimNode(nnkOfInherit).add(ident(obj.parentName))) @@ -503,11 +503,11 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = result.add(meth.nimNode) # Register Godot object - let parentName = if obj.parentName == "": newStrLitNode("Object") + let parentName = if obj.parentName.len == 0: newStrLitNode("Object") else: newStrLitNode(obj.parentName) let classNameLit = newStrLitNode(obj.name) let classNameIdent = ident(obj.name) - let isRef: bool = if obj.parentName == "": false + let isRef: bool = if obj.parentName.len == 0: false else: obj.parentName in refClasses # Wrapping bools with a newLit is required as a temporary workaround for # https://github.com/nim-lang/Nim/issues/7375 @@ -544,9 +544,15 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = template registerGodotMethod(classNameLit, classNameIdent, methodNameIdent, methodNameLit, minArgs, maxArgs, argTypes, methFuncIdent, hasReturnValue) = - {.emit: """/*TYPESECTION*/ + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + {.emit: """/*TYPESECTION*/ +N_NOINLINE(void, setStackBottom)(void* thestackbottom); +""".} + else: + {.emit: """ N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); """.} + proc methFuncIdent(obj: ptr GodotObject, methodData: pointer, userData: pointer, numArgs: cint, args: var array[MAX_ARG_COUNT, ptr GodotVariant]): diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 41ef51e..e58c330 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -202,7 +202,7 @@ macro baseNativeType(T: typedesc): cstring = if typeName == "NimGodotObject": break t = getType(t[1][1]) - if baseT == "": + if baseT.len == 0: result = newNilLit() else: let rStr = newNimNode(nnkRStrLit) @@ -343,7 +343,7 @@ proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) result.strVal = s -proc toGodotName(T: typedesc): string = +macro toGodotName(T: typedesc): string = if T is GodotString or T is string: "String" elif T is SomeFloat: @@ -708,10 +708,16 @@ proc toVariant*(s: string): Variant {.inline.} = proc fromVariant*(s: var string, val: Variant): ConversionResult = if val.getType() == VariantType.String: s = val.asString() - elif val.getType() == VariantType.Nil: - s = "" + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + if val.getType() == VariantType.Nil: + s = nil + else: + result = ConversionResult.TypeError else: - result = ConversionResult.TypeError + if val.getType() == VariantType.Nil: + s = "" + else: + result = ConversionResult.TypeError template arrTypeInfo(T) = result.variantType = VariantType.Array @@ -829,10 +835,16 @@ proc fromVariant*[T: Table or TableRef or OrderedTable or OrderedTableRef](t: va else: result = ConversionResult.TypeError -{.emit: """/*TYPESECTION*/ -N_LIB_EXPORT N_CDECL(void, NimMain)(void); -N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); -""".} +when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + {.emit: """/*TYPESECTION*/ + N_LIB_EXPORT N_CDECL(void, NimMain)(void); + N_NOINLINE(void, setStackBottom)(void* thestackbottom); + """.} +else: + {.emit: """/*TYPESECTION*/ + N_LIB_EXPORT N_CDECL(void, NimMain)(void); + N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); + """.} var nativeLibHandle: pointer proc getNativeLibHandle*(): pointer = From 0fecfdb3b85922f7a0be0e132be48ca430ba0ad1 Mon Sep 17 00:00:00 2001 From: Dwana Games Date: Fri, 21 Jun 2019 20:11:29 -0500 Subject: [PATCH 141/160] Updated to work with nim 0.20 - Attempt to fix deprecated this:self pragma by injecting self to methods and properties (needs more testing) - Changed import headers to use / (slash) instead of . (period) - Fixed object branch in godotapigen.nim - Fixed deprecated nimNode.ident with nimNode.strVal Fix toGodotName function Consider procCall calls as special cases, otherwise it gives problems in _init function Fix infinite recursive call in Godot 3.2 --- godot/core/aabb.nim | 2 +- godot/core/arrays.nim | 2 +- godot/core/dictionaries.nim | 4 +- godot/core/nodepaths.nim | 4 +- godot/core/planes.nim | 2 +- godot/core/poolarrays.nim | 4 +- godot/core/quats.nim | 2 +- godot/core/rect2.nim | 2 +- godot/core/rids.nim | 2 +- godot/core/transform2d.nim | 2 +- godot/core/transforms.nim | 2 +- godot/core/variants.nim | 6 +- godot/core/vector2.nim | 2 +- godot/gdnativeapi.nim | 4 +- godot/godot.nim | 16 +- godot/godotapigen.nim | 262 +++++++++++++++-------------- godot/godotinternal.nim | 6 +- godot/internal/godotarrays.nim | 2 +- godot/internal/godotpoolarrays.nim | 2 +- godot/internal/godotvariants.nim | 2 +- godot/nim/godotmacros.nim | 144 ++++++++++++---- godot/nim/godotnim.nim | 28 +-- godot/nim/nim.cfg | 3 +- 23 files changed, 294 insertions(+), 211 deletions(-) diff --git a/godot/core/aabb.nim b/godot/core/aabb.nim index 66425a2..2d816da 100644 --- a/godot/core/aabb.nim +++ b/godot/core/aabb.nim @@ -3,7 +3,7 @@ import hashes import vector3 -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi proc initAABB*(pos, size: Vector3): AABB {.inline.} = diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index afe8131..fcbafb2 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,7 +1,7 @@ # Copyright 2018 Xored Software, Inc. import hashes -import internal.godotinternaltypes, internal.godotarrays +import internal/godotinternaltypes, internal/godotarrays type Array* = ref object diff --git a/godot/core/dictionaries.nim b/godot/core/dictionaries.nim index 4a160f2..3aea17a 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,8 +1,8 @@ # Copyright 2018 Xored Software, Inc. import hashes -import internal.godotinternaltypes, internal.godotdictionaries, - internal.godotvariants, internal.godotstrings +import internal/godotinternaltypes, internal/godotdictionaries, + internal/godotvariants, internal/godotstrings type Dictionary* = ref object diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index 831c855..bf690d7 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -2,8 +2,8 @@ import hashes -import internal.godotinternaltypes, internal.godotnodepaths, - internal.godotstrings +import internal/godotinternaltypes, internal/godotnodepaths, + internal/godotstrings type NodePath* = ref object diff --git a/godot/core/planes.nim b/godot/core/planes.nim index 815a5c6..2d15c79 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -4,7 +4,7 @@ import hashes import vector3 -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi proc initPlane*(a, b, c, d: float32): Plane {.inline.} = diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index 29aca98..eac4cf4 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -3,8 +3,8 @@ import hashes import godotcoretypes -import internal.godotinternaltypes, internal.godotpoolarrays, - internal.godotstrings +import internal/godotinternaltypes, internal/godotpoolarrays, + internal/godotstrings import vector2, vector3, colors template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, diff --git a/godot/core/quats.nim b/godot/core/quats.nim index 1a8da82..db88b10 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -2,7 +2,7 @@ import hashes -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi proc initQuat*(x, y, z, w: float32): Quat {.inline.} = diff --git a/godot/core/rect2.nim b/godot/core/rect2.nim index 8a0a1c8..19b8cbf 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -3,7 +3,7 @@ import hashes import vector2 -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi {.push stackTrace: off.} diff --git a/godot/core/rids.nim b/godot/core/rids.nim index 800207f..a64137d 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -2,7 +2,7 @@ import hashes -import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import godotcoretypes, internal/godotinternaltypes, gdnativeapi proc initRID*(): RID {.inline.} = getGDNativeAPI().ridNew(result) diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index 16f62bd..a8db09e 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -2,7 +2,7 @@ import hashes, vector2 -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi proc initTransform2D*(): Transform2D {.inline.} = diff --git a/godot/core/transforms.nim b/godot/core/transforms.nim index 4a21466..501f743 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -2,7 +2,7 @@ import hashes -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi import basis, vector3 diff --git a/godot/core/variants.nim b/godot/core/variants.nim index 8c2488d..ce1d945 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -1,9 +1,9 @@ import tables, hashes import godotcoretypes -import internal.godotinternaltypes, internal.godotvariants, - internal.godotstrings, internal.godotdictionaries, - internal.godotarrays +import internal/godotinternaltypes, internal/godotvariants, + internal/godotstrings, internal/godotdictionaries, + internal/godotarrays type Variant* = ref object diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 1c8aa5e..01c0312 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -2,7 +2,7 @@ import math, godotbase, hashes -import internal.godotinternaltypes, internal.godotstrings +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi {.push stackTrace: off.} diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 591d45e..bb05425 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1,6 +1,6 @@ # Copyright 2018 Xored Software, Inc. -import internal.godotinternaltypes, core.godotcoretypes, macros +import internal/godotinternaltypes, core/godotcoretypes, macros type ColorData* {.byref.} = object @@ -3593,7 +3593,7 @@ proc setGDNativeAPIInternal(apiStruct: pointer, initOptions: ptr GDNativeInitOpt # Not used discard - if not header.next.isNil: + if not header.next.isNil and header != header.next: setGDNativeAPIInternal(header.next, initOptions, foundCoreApi, foundNativeScriptApi) diff --git a/godot/godot.nim b/godot/godot.nim index f4a9bf8..809f58f 100644 --- a/godot/godot.nim +++ b/godot/godot.nim @@ -1,14 +1,14 @@ # Copyright 2018 Xored Software, Inc. -import core.godotbase, godotinternal -import core.godotcoretypes -import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes, - core.quats -import core.aabb, core.basis, core.transforms, core.colors, core.nodepaths, - core.rids -import core.dictionaries, core.arrays, core.poolarrays, core.variants +import core/godotbase, godotinternal +import core/godotcoretypes +import core/vector2, core/rect2, core/vector3, core/transform2d, core/planes, + core/quats +import core/aabb, core/basis, core/transforms, core/colors, core/nodepaths, + core/rids +import core/dictionaries, core/arrays, core/poolarrays, core/variants -import nim.godotmacros, nim.godotnim +import nim/godotmacros, nim/godotnim export godotbase, godotcoretypes, vector2, rect2, vector3, transform2d, planes, quats, aabb, basis, transforms, colors, nodepaths, rids, dictionaries, diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 71a52ff..a53ee6f 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -2,17 +2,22 @@ import streams, json, os, strutils, times, sets, tables, options import sequtils, algorithm -import compiler.ast, compiler.renderer, compiler.idents, compiler.astalgo +import compiler/ast, compiler/renderer, compiler/idents, compiler/astalgo, compiler/lineinfos when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0): - var gic* = newIdentCache() + var gic = newIdentCache() proc getIdent(ident: string): PIdent = getIdent(gic, ident) proc ident(ident: string): PNode = - result = newNode(nkIdent) - result.ident = getIdent(ident) + result = PNode(kind: nkIdent, ident: getIdent(ident)) + +proc newPNode(kind: TNodeKind): PNode = + result = PNode(kind: kind) + result.info.fileIndex = InvalidFileIdx + result.info.col = int16(-1) + result.info.line = uint16(0) proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} = for other in others: @@ -21,37 +26,37 @@ proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} = proc newIdentDefs(name, typ: PNode, defaultVal: PNode = nil): PNode = - result = newNode(nkIdentDefs) + result = newPNode(nkIdentDefs) result.add(name) result.add(typ) if defaultVal.isNil: - result.add(newNode(nkEmpty)) + result.add(newPNode(nkEmpty)) else: result.add(defaultVal) -proc newProc(name: PNode, params: openArray[PNode], body = newNode(nkEmpty), +proc newProc(name: PNode, params: openArray[PNode], body = newPNode(nkEmpty), procType = nkProcDef): PNode = - result = newNode(procType) + result = newPNode(procType) result.add(name) - result.add(newNode(nkEmpty)) - result.add(newNode(nkEmpty)) - let formalParams = newNode(nkFormalParams) + result.add(newPNode(nkEmpty)) + result.add(newPNode(nkEmpty)) + let formalParams = newPNode(nkFormalParams) for param in params: formalParams.add(param) result.add(formalParams) - result.add(newNode(nkEmpty)) - result.add(newNode(nkEmpty)) + result.add(newPNode(nkEmpty)) + result.add(newPNode(nkEmpty)) result.add(body) proc newIfStmt(condition, body: PNode): PNode = - result = newNode(nkIfStmt) - let branch = newNode(nkElifBranch) + result = newPNode(nkIfStmt) + let branch = newPNode(nkElifBranch) result.add(branch) branch.add(condition) branch.add(body) proc newCall(theProc: PNode, args: varargs[PNode]): PNode = - result = newNode(nkCall) + result = newPNode(nkCall) result.add(theProc) for arg in args: result.add(arg) @@ -60,66 +65,66 @@ proc newCall(theProc: string, args: varargs[PNode]): PNode = newCall(ident(theProc), args) proc newStrLit(s: string): PNode = - result = newNode(nkStrLit) + result = newPNode(nkStrLit) result.strVal = s proc newRStrLit(s: string): PNode = - result = newNode(nkRStrLit) + result = newPNode(nkRStrLit) result.strVal = s proc newCStringLit(s: string): PNode = - newNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s)) + newPNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s)) proc newIntLit(val: BiggestInt): PNode = - result = newNode(nkIntLit) + result = newPNode(nkIntLit) result.intVal = val proc newInt64Lit(val: BiggestInt): PNode = - result = newNode(nkInt64Lit) + result = newPNode(nkInt64Lit) result.intVal = val proc newFloatLit(val: BiggestFloat): PNode = - result = newNode(nkFloatLit) + result = newPNode(nkFloatLit) result.floatVal = val proc newFloat64Lit(val: BiggestFloat): PNode = - result = newNode(nkFloat64Lit) + result = newPNode(nkFloat64Lit) result.floatVal = val proc newNilLit(): PNode = - result = newNode(nkNilLit) + result = newPNode(nkNilLit) proc newDotExpr(left, right: PNode): PNode = - result = newNode(nkDotExpr) + result = newPNode(nkDotExpr) result.add(left) result.add(right) proc newCommand(left, right: PNode): PNode = - result = newNode(nkCommand) + result = newPNode(nkCommand) result.add(left) result.add(right) proc infix(left, op, right: PNode): PNode = - result = newNode(nkInfix) + result = newPNode(nkInfix) result.add(op) result.add(left) result.add(right) proc postfix(left: PNode, op: string): PNode = - result = newNode(nkPostfix) + result = newPNode(nkPostfix) result.add(ident(op)) result.add(left) proc prefix(op: string, right: PNode): PNode = - result = newNode(nkPrefix) + result = newPNode(nkPrefix) result.add(ident(op)) result.add(right) proc newBracketExpr(first, bracket: PNode): PNode = - newNode(nkBracketExpr).addChain(first, bracket) + newPNode(nkBracketExpr).addChain(first, bracket) proc newEmptyNode(): PNode = - newNode(nkEmpty) + newPNode(nkEmpty) type GodotType = ref object name: string @@ -212,42 +217,42 @@ proc toNimStyle(name: string): string = proc newRefTypeNode(typeSection: PNode, typ, base, doc: string, isExported = true) = - let typeDef = newNode(nkTypeDef) + let typeDef = newPNode(nkTypeDef) typeSection.add(typeDef) if isExported: typeDef.add(postfix(ident(typ), "*")) else: typeDef.add(ident(typ)) - typeDef.add(newNode(nkEmpty)) # generic - let objTy = newNode(nkObjectTy) - let refTy = newNode(nkRefTy) + typeDef.add(newPNode(nkEmpty)) # generic + let objTy = newPNode(nkObjectTy) + let refTy = newPNode(nkRefTy) refTy.add(objTy) typeDef.add(refTy) - objTy.add(newNode(nkEmpty)) - let inherit = newNode(nkOfInherit) + objTy.add(newPNode(nkEmpty)) + let inherit = newPNode(nkOfInherit) inherit.add(ident(base)) objTy.add(inherit) if doc.len > 0: - let recList = newNode(nkRecList) - let docNode = newNode(nkCommentStmt) + let recList = newPNode(nkRecList) + let docNode = newPNode(nkCommentStmt) docNode.comment = doc recList.add(docNode) objTy.add(recList) else: - objTy.add(newNode(nkEmpty)) + objTy.add(newPNode(nkEmpty)) proc makeConstSection(constObj: JsonNode): PNode = if constObj.len == 0: - return newNode(nkEmpty) + return newPNode(nkEmpty) - result = newNode(nkConstSection) + result = newPNode(nkConstSection) for field, val in constObj: - let def = newNode(nkConstDef) + let def = newPNode(nkConstDef) def.add(postfix(ident(field), "*")) - def.add(newNode(nkEmpty)) # infer type + def.add(newPNode(nkEmpty)) # infer type var valNode: PNode if val.kind == JInt: valNode = newInt64Lit(val.num) @@ -257,7 +262,7 @@ proc makeConstSection(constObj: JsonNode): PNode = elif val.kind == JBool: valNode = ident($val.bval) elif val.kind == JString: - valNode = newNode(nkStrLit) + valNode = newPNode(nkStrLit) valNode.strVal = val.str else: raise newException(ValueError, "Unexpected constant kind: " & $val.kind) @@ -286,7 +291,7 @@ type isBase: bool isDiscardable: bool -const standardTypes = toSet( +const standardTypes = toHashSet( ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "Error", "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", @@ -295,18 +300,18 @@ const standardTypes = toSet( "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) -const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", - "int32", "cint", "int", "Error"]) -const int64Types = toSet(["uint64", "int64"]) +const smallIntTypes = toHashSet(["uint8", "int8", "uint16", "int16", "uint32", + "int32", "cint", "int", "Error"]) +const int64Types = toHashSet(["uint64", "int64"]) const intTypes = union(smallIntTypes, int64Types) -const float64Types = toSet(["float64", "cdouble"]) -const float32Types = toSet(["float32", "cfloat"]) +const float64Types = toHashSet(["float64", "cdouble"]) +const float32Types = toHashSet(["float32", "cfloat"]) const floatTypes = union(float64Types, float32Types) -const arrayTypes = toSet(["Array", "PoolByteArray", +const arrayTypes = toHashSet(["Array", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) const wrapperTypes = union(arrayTypes, - toSet(["NodePath", "Dictionary", "Variant"])) + toHashSet(["NodePath", "Dictionary", "Variant"])) proc getInternalPtr(varName: PNode, typ: string): PNode = assert(typ in wrapperTypes) @@ -314,7 +319,7 @@ proc getInternalPtr(varName: PNode, typ: string): PNode = proc newNilCheck(ident, toAssign: PNode): PNode = newIfStmt(newCall("isNil", ident), - newNode(nkAsgn).addChain(ident).addChain( + newPNode(nkAsgn).addChain(ident).addChain( toAssign ) ) @@ -387,6 +392,8 @@ proc makeDefaultValue(arg: MethodArg): PNode = result = newCall("newVariant") else: failed = true + elif arg.typ == "Dictionary": + result = newCall("newDictionary") else: failed = true @@ -403,12 +410,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], meth: MethodInfo, withImplementation: bool) = var body: PNode if not withImplementation: - body = newNode(nkEmpty) + body = newPNode(nkEmpty) elif meth.godotName == "_init" and meth.typ.godotName == "Object": # It's not real (calling it crashes) and will be removed later, # but we use init() convention in Nim, so it needs to work. - body = newNode(nkStmtList).addChain( - newNode(nkDiscardStmt).addChain(newNode(nkEmpty))) + body = newPNode(nkStmtList).addChain( + newPNode(nkDiscardStmt).addChain(newPNode(nkEmpty))) else: let methGodotName = if meth.godotName.startsWith('_'): "underscore" & meth.godotName[1..^1] @@ -419,12 +426,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if methodBindName[0].isUpperAscii(): methodBindName[0] = methodBindName[0].toLowerAscii() if methodBindName notin methodBindRegistry: - let methodBindDecl = newNode(nkVarSection).addChain( + let methodBindDecl = newPNode(nkVarSection).addChain( newIdentDefs( - newNode(nkPragmaExpr).addChain( + newPNode(nkPragmaExpr).addChain( ident(methodBindName)).addChain( - newNode(nkPragma).addChain(ident("threadvar"))), - newNode(nkPtrTy).addChain(ident("GodotMethodBind")) + newPNode(nkPragma).addChain(ident("threadvar"))), + newPNode(nkPtrTy).addChain(ident("GodotMethodBind")) )) tree.add(methodBindDecl) methodBindRegistry.incl(methodBindName) @@ -433,7 +440,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newCall("getMethod", newCStringLit(meth.typ.godotName), newCStringLit(meth.godotName)) ) - let vars = newNode(nkVarSection) + let vars = newPNode(nkVarSection) var varargsName = none(string) var isVarargs: bool var staticArgsLen: int @@ -448,13 +455,13 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], elif arg.kind == ArgKind.Bound: let argName = boundArgName(idx) vars.add(newIdentDefs( - ident(argName), newNode(nkEmpty), arg.makeDefaultValue())) + ident(argName), newPNode(nkEmpty), arg.makeDefaultValue())) - let argsAlloc = newNode(nkCast).addChain( - newNode(nkPtrTy).addChain( - newNode(nkBracketExpr).addChain( + let argsAlloc = newPNode(nkCast).addChain( + newPNode(nkPtrTy).addChain( + newPNode(nkBracketExpr).addChain( ident("array"), ident("MAX_ARG_COUNT"), - if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant")) + if isVarargs: newPNode(nkPtrTy).addChain(ident("GodotVariant")) else: ident("pointer")))) staticArgsLen = if varargsName.isNone: meth.args.len else: meth.args.len - 1 @@ -465,24 +472,24 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newDotExpr(ident(varargsName.get), ident("len")))) argsAlloc.add(newCall("godotAlloc", newCall("cint", infix( newCall("sizeof", ident("Variant")), ident("*"), - newNode(nkPar).addChain(argLenNode)))) + newPNode(nkPar).addChain(argLenNode)))) ) else: argLenNode = newCall("cint", newIntLit(staticArgsLen)) vars.add(newIdentDefs( ident("argsStatic"), - newNode(nkBracketExpr).addChain( + newPNode(nkBracketExpr).addChain( ident("array"), newIntLit(staticArgsLen), ident("pointer")), - newNode(nkEmpty))) + newPNode(nkEmpty))) argsAlloc.add(newCommand(ident("addr"), ident("argsStatic"))) - vars.add(newIdentDefs(argsName, newNode(nkEmpty), argsAlloc)) + vars.add(newIdentDefs(argsName, newPNode(nkEmpty), argsAlloc)) - let argConversions = newNode(nkStmtList) + let argConversions = newPNode(nkStmtList) for idx, arg in meth.args: var argName = if arg.kind == ArgKind.Bound: ident(boundArgName(idx)) else: ident(arg.name) if arg.kind == ArgKind.VarArgs: - argName = newNode(nkBracketExpr).addChain( + argName = newPNode(nkBracketExpr).addChain( ident(varargsName.get), infix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) let argIdx = if arg.kind == ArgKind.VarArgs: ident("idx") else: newIntLit(idx) @@ -501,19 +508,19 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], [arg.typ, meth.godotName, meth.typ.godotName]) if not isStandardType and varargsName.isNone: if arg.typ == "string": - argConversions.add(newNode(nkVarSection).addChain( + argConversions.add(newPNode(nkVarSection).addChain( newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), newCall("toGodotString", argName)))) else: let objVal = newIfStmt( prefix("not", newDotExpr(argName, ident"isNil")), newDotExpr(argName, ident("godotObject")) - ).addChain(newNode(nkElse).addChain(newNilLit())) - argConversions.add(newNode(nkLetSection).addChain( + ).addChain(newPNode(nkElse).addChain(newNilLit())) + argConversions.add(newPNode(nkLetSection).addChain( newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), objVal))) - let argAsgn = newNode(nkAsgn).addChain( - newNode(nkBracketExpr).addChain( - newNode(nkBracketExpr).addChain(argsName), argIdx), + let argAsgn = newPNode(nkAsgn).addChain( + newPNode(nkBracketExpr).addChain( + newPNode(nkBracketExpr).addChain(argsName), argIdx), convArg ) if arg.kind != ArgKind.VarArgs: @@ -521,14 +528,14 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], argAsgn ) else: - argConversions.add(newNode(nkVarSection).addChain( - newIdentDefs(ident("idx"), newNode(nkEmpty), + argConversions.add(newPNode(nkVarSection).addChain( + newIdentDefs(ident("idx"), newPNode(nkEmpty), newIntLit(staticArgsLen)))) - let argLoop = newNode(nkWhileStmt) + let argLoop = newPNode(nkWhileStmt) argConversions.add(argLoop) argLoop.add(infix(ident("idx"), ident("<"), argLenNode) ) - argLoop.add(newNode(nkStmtList).addChain( + argLoop.add(newPNode(nkStmtList).addChain( argAsgn, newCommand(ident("inc"), ident("idx")))) @@ -537,26 +544,26 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newDotExpr(ident(methodBindName), ident(if isVarargs: "call" else: "ptrCall")), newDotExpr(ident("self"), ident("godotObject")), - if meth.args.len > 0: argsName else: newNode(nkNilLit), + if meth.args.len > 0: argsName else: newPNode(nkNilLit), argLenNode, if not isVarargs: ident(retName) else: ident("callError") ) if not isVarargs: theCall.sons.delete(3) let freeCall = newCall("godotFree", argsName) - body = newNode(nkStmtList) + body = newPNode(nkStmtList) if meth.typ.isSingleton: let varName = singletonName(meth.typ.name) body.add(newNilCheck(varName, newCall( newBracketExpr(ident("getSingleton"), ident(meth.typ.name))))) - body.add(newNode(nkLetSection).addChain(newIdentDefs( - ident("self"), newNode(nkEmpty), varName + body.add(newPNode(nkLetSection).addChain(newIdentDefs( + ident("self"), newPNode(nkEmpty), varName ))) body.add(nilCheck) body.add(vars) body.add(argConversions) if not isVarargs: - let retPtrDecl = newNode(nkVarSection).addChain( + let retPtrDecl = newPNode(nkVarSection).addChain( newIdentDefs(ident(retName), ident("pointer"), newEmptyNode()) ) body.add(retPtrDecl) @@ -571,43 +578,43 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], var addrToAssign = newCall("addr", retValIdent) if returnType in smallIntTypes: isConversionRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( + body.add(newPNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("int64"), ))) elif returnType in float32Types: isConversionRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( + body.add(newPNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("float64"), ))) elif returnType in wrapperTypes: isWrapperRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( + body.add(newPNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("Godot" & returnType), ))) elif returnType in standardTypes: addrToAssign = newCall("addr", ident("result")) elif returnType == "string": isStringRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( + body.add(newPNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("GodotString"), ))) elif returnType != "void": isObjRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( - retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")), + body.add(newPNode(nkVarSection).addChain(newIdentDefs( + retValIdent, newPNode(nkPtrTy).addChain(ident("GodotObject")), ))) - body.add(newNode(nkAsgn).addChain(ident(retName), addrToAssign)) + body.add(newPNode(nkAsgn).addChain(ident(retName), addrToAssign)) if not isVarargs: body.add(theCall) else: if meth.returnType.isSome: isVariantRet = true - let callStmt = newNode(nkLetSection).addChain( + let callStmt = newPNode(nkLetSection).addChain( newIdentDefs( - newNode(nkPragmaExpr).addChain( - ident(retName), newNode(nkPragma).addChain(ident("used"))), - newNode(nkEmpty), theCall)) + newPNode(nkPragmaExpr).addChain( + ident(retName), newPNode(nkPragma).addChain(ident("used"))), + newPNode(nkEmpty), theCall)) body.add(callStmt) if varargsName.isNone: @@ -621,42 +628,42 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], let errCheck = newIfStmt( infix(newDotExpr(ident("callError"), ident("error")), ident("!="), newDotExpr(ident("VariantCallErrorType"), ident("OK"))), - newNode(nkRaiseStmt).addChain( + newPNode(nkRaiseStmt).addChain( newCall("newCallError", ident("callError"))) ) body.add(errCheck) if isVariantRet: - let convErrDef = newNode(nkLetSection).addChain( - newIdentDefs(ident("convErr"), newNode(nkEmpty), + let convErrDef = newPNode(nkLetSection).addChain( + newIdentDefs(ident("convErr"), newPNode(nkEmpty), newCall("fromVariant", ident("result"), newCall("newVariant", retValIdent)))) let convCheck = newIfStmt( infix(ident("convErr"), ident("!="), newDotExpr(ident("ConversionResult"), ident("OK"))), - newNode(nkRaiseStmt).addChain( + newPNode(nkRaiseStmt).addChain( newCall("newConversionError", ident("convErr"))) ) body.add(convErrDef) body.add(convCheck) if isStringRet: - body.add(newNode(nkAsgn).addChain( + body.add(newPNode(nkAsgn).addChain( ident("result"), prefix("$", retValIdent))) body.add(newCall("deinit", retValIdent)) elif isConversionRet: - body.add(newNode(nkAsgn).addChain( + body.add(newPNode(nkAsgn).addChain( ident("result"), newCall(meth.returnType.get, retValIdent))) elif isWrapperRet: - body.add(newNode(nkAsgn).addChain( + body.add(newPNode(nkAsgn).addChain( ident("result"), newCall("new" & meth.returnType.get, retValIdent))) elif isObjRet: - body.add(newNode(nkAsgn).addChain(ident("result"), + body.add(newPNode(nkAsgn).addChain(ident("result"), newCall(newBracketExpr(ident("asNimGodotObject"), newCall("type", ident("result"))), retValIdent, ident("false"), ident("true")))) elif isStringRet: - body.add(newNode(nkAsgn).addChain(ident("result"), + body.add(newPNode(nkAsgn).addChain(ident("result"), newCall("$", retValIdent))) let procType = if meth.isVirtual: nkMethodDef @@ -665,7 +672,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if meth.returnType.isSome: params.add(ident(meth.returnType.get)) else: - params.add(newNode(nkEmpty)) + params.add(newPNode(nkEmpty)) if not meth.typ.isSingleton: params.add(newIdentDefs(ident("self"), ident(toNimType(meth.typ.name)))) @@ -676,7 +683,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue)) of ArgKind.VarArgs: params.add(newIdentDefs(ident(arg.name), - newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) + newPNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ)))) of ArgKind.Bound: discard @@ -684,9 +691,9 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], else: meth.name, params, body, procType) if not withImplementation: - let pragma = newNode(nkPragma) + let pragma = newPNode(nkPragma) pragma.add(ident("gcsafe")) - pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"), + pragma.add(newPNode(nkExprColonExpr).addChain(ident("locks"), newIntLit(0))) if meth.isVirtual and meth.isBase and meth.typ.name != "PhysicsBody": # Nim doesn't like `base` on PhysicsBody methods - wtf @@ -738,7 +745,7 @@ proc getMethodInfo(methodObj: JsonNode, types: Table[string, GodotType], let returnType = if methodObj["return_type"].str != "void": some(toNimType(types, methodObj["return_type"].str)) else: none(string) - const discardableMethods = toSet(["emit_signal"]) + const discardableMethods = toHashSet(["emit_signal"]) result = MethodInfo( name: ident(nimName), typ: typ, @@ -767,7 +774,7 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode, return let getterNameStr = toNimStyle(propertyObj["name"].str) let getterName = ident(getterNameStr) - let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) + let setterName = newPNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) let getter = findMethod(obj, propertyObj["getter"].str) let nimType = if getter.isNil: toNimType(types, propertyObj["type"].str) @@ -853,10 +860,10 @@ proc newRegisterClassNode(typ: GodotType): PNode = ) proc genSingletonDecl(typ: string): PNode = - result = newNode(nkVarSection) + result = newPNode(nkVarSection) let name = singletonName(typ) - let threadvar = newNode(nkPragma).addChain(ident("threadvar")) - result.add(newIdentDefs(newNode(nkPragmaExpr).addChain(name, threadvar), + let threadvar = newPNode(nkPragma).addChain(ident("threadvar")) + result.add(newIdentDefs(newPNode(nkPragmaExpr).addChain(name, threadvar), ident(typ))) proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool = @@ -873,9 +880,9 @@ proc sortByDerivedCount(types: Table[string, GodotType]): seq[GodotType] = proc genTypeFile(types: Table[string, GodotType], targetDir: string) = let sortedTypes = sortByDerivedCount(types) - let godotApiTypesTree = newNode(nkStmtList) - godotApiTypesTree.add(newNode(nkImportStmt).addChain(ident("godot"))) - let typeSection = newNode(nkTypeSection) + let godotApiTypesTree = newPNode(nkStmtList) + godotApiTypesTree.add(newPNode(nkImportStmt).addChain(ident("godot"))) + let typeSection = newPNode(nkTypeSection) godotApiTypesTree.add(typeSection) for typ in sortedTypes: @@ -897,10 +904,10 @@ proc genSingletonWithDerived(tree: PNode, typ: GodotType, types: Table[string, GodotType]) = let sortedTypes = sortByDerivedCount(types) - var parents = initSet[string]() + var parents = initHashSet[string]() parents.incl(typ.name) - let typeDecl = newNode(nkTypeSection) + let typeDecl = newPNode(nkTypeSection) tree.add(typeDecl) proc genDecl(typ: GodotType) = newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc, @@ -950,17 +957,17 @@ proc genApi*(targetDir: string, apiJsonFile: string) = for typ in types.values(): let moduleName = typeNameToModuleName(typ.name) echo "Generating ", moduleName, ".nim..." - let tree = newNode(nkStmtList) - let importStmt = newNode(nkImportStmt) + let tree = newPNode(nkStmtList) + let importStmt = newPNode(nkImportStmt) importStmt.add(ident("godot")) importStmt.add(ident("godottypes")) importStmt.add(ident("godotinternal")) tree.add(importStmt) - let exportStmt = newNode(nkExportStmt) + let exportStmt = newPNode(nkExportStmt) exportStmt.add(ident("godottypes")) tree.add(exportStmt) - var methodBindRegsitry = initSet[string]() + var methodBindRegsitry = initHashSet[string]() let obj = typ.jsonNode if typ.baseName != "NimGodotObject": let baseModule = typeNameToModuleName(typ.baseName) @@ -1021,7 +1028,6 @@ when isMainModule: import os const usage = """Tool for wrapping Godot API into Nim - godotapigen [godot binary path] [target directory]""" proc main() = @@ -1052,4 +1058,4 @@ when isMainModule: genApi(targetDir, jsonFile) - main() + main() \ No newline at end of file diff --git a/godot/godotinternal.nim b/godot/godotinternal.nim index ce83428..207d76f 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -1,8 +1,8 @@ # Copyright 2018 Xored Software, Inc. -import internal.godotinternaltypes, internal.godotarrays, - internal.godotnodepaths, internal.godotpoolarrays, internal.godotstrings, - internal.godotvariants, internal.godotdictionaries +import internal/godotinternaltypes, internal/godotarrays, + internal/godotnodepaths, internal/godotpoolarrays, internal/godotstrings, + internal/godotvariants, internal/godotdictionaries import gdnativeapi export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays, diff --git a/godot/internal/godotarrays.nim b/godot/internal/godotarrays.nim index c0736b5..c7e451d 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -1,6 +1,6 @@ # Copyright (c) 2018 Xored Software, Inc. -import godotinternaltypes, gdnativeapi, core.godotcoretypes +import godotinternaltypes, gdnativeapi, core/godotcoretypes proc len*(self: GodotArray): cint {.inline.} = getGDNativeAPI().arraySize(self) diff --git a/godot/internal/godotpoolarrays.nim b/godot/internal/godotpoolarrays.nim index 5fe9419..119848f 100644 --- a/godot/internal/godotpoolarrays.nim +++ b/godot/internal/godotpoolarrays.nim @@ -1,7 +1,7 @@ # Copyright (c) 2018 Xored Software, Inc. import godotinternaltypes, gdnativeapi -import core.godotcoretypes +import core/godotcoretypes template genPoolArrayAPI(ArrayT, initIdent, DataT, newProc, newCopyProc, newWithArrayProc, appendProc, diff --git a/godot/internal/godotvariants.nim b/godot/internal/godotvariants.nim index fec75cd..0a0980f 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -1,6 +1,6 @@ # Copyright 2018 Xored Software, Inc. -import core.godotcoretypes, godotinternaltypes, gdnativeapi +import core/godotcoretypes, godotinternaltypes, gdnativeapi proc getType*(p: GodotVariant): VariantType {.inline.} = getGDNativeAPI().variantGetType(p) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 4389859..f6a613a 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -1,8 +1,8 @@ # Copyright 2018 Xored Software, Inc. -import macros, tables, typetraits, strutils, sets, sequtils, options -import godotinternal, internal.godotvariants -import godotnim, core.variants +import macros, tables, typetraits, strutils, sets, sequtils, options, algorithm +import godotinternal, internal/godotvariants +import godotnim, core/variants type VarDecl = ref object @@ -51,15 +51,15 @@ template parseError(node: NimNode, msg: string) = proc extractNames(definition: NimNode): tuple[name, parentName: string] = if definition.kind == nnkIdent: - result.name = $(definition.ident) + result.name = definition.strVal else: if not (definition.kind == nnkInfix and - definition[0].ident == toNimIdent("of")): + definition[0].strVal == "of"): parseError(definition, "invalid type definition") - result.name = $(definition[1].ident) + result.name = definition[1].strVal case definition[2].kind: of nnkIdent: - result.parentName = $definition[2].ident + result.parentName = definition[2].strVal else: parseError(definition[2], "parent type expected") @@ -72,13 +72,13 @@ proc newCStringLit(s: string): NimNode {.compileTime.} = newNimNode(nnkCallStrLit).add(ident("cstring"), newRStrLit(s)) iterator pragmas(node: NimNode): - tuple[key: NimIdent, value: NimNode, index: int] = + tuple[key: string, value: NimNode, index: int] = assert node.kind in {nnkPragma, nnkEmpty} for index in countdown(node.len - 1, 0): if node[index].kind == nnkExprColonExpr: - yield (node[index][0].ident, node[index][1], index) + yield (node[index][0].strVal, node[index][1], index) elif node[index].kind == nnkIdent: - yield (node[index].ident, nil, index) + yield (node[index].strVal, nil, index) proc removePragmaNode(statement: NimNode, pname: string): NimNode {.compileTime.} = @@ -91,9 +91,8 @@ proc removePragmaNode(statement: NimNode, result = nil var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma() else: statement[1] - let pnameIdent = toNimIdent(pname) for ident, val, i in pragmas(pragmas): - if ident == pnameIdent: + if ident == pname: pragmas.del(i) return val @@ -104,9 +103,8 @@ proc removePragma(statement: NimNode, pname: string): bool = return false var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma() else: statement[1] - let pnameIdent = toNimIdent(pname) for ident, val, i in pragmas(pragmas): - if ident == pnameIdent: + if ident == pname: pragmas.del(i) return true @@ -178,8 +176,9 @@ proc parseVarSection(decl: NimNode): seq[VarDecl] = else: result.add(identDefsToVarDecls(decl[i])) -proc parseType(definition, callSite: NimNode): ObjectDecl = - let body = callSite[^1] +proc parseType(ast: NimNode): ObjectDecl = + let definition = ast[0] + let body = ast[^1] result = ObjectDecl( fields: newSeq[VarDecl](), methods: newSeq[MethodDecl]() @@ -187,11 +186,11 @@ proc parseType(definition, callSite: NimNode): ObjectDecl = (result.name, result.parentName) = extractNames(definition) var isTool = false - for i in 2..(callSite.len - 2): - let option = callSite[i] + for i in 1..(ast.len - 2): + let option = ast[i] if option.kind != nnkIdent: parseError(option, "type specifier expected") - if option.ident == toNimIdent("tool"): + if option.strVal == "tool": isTool = true else: parseError(option, "valid type specifier expected") @@ -214,7 +213,7 @@ proc parseType(definition, callSite: NimNode): ObjectDecl = macro invokeVarArgs(procIdent, objIdent; minArgs, maxArgs: static[int], numArgsIdent, argSeqIdent; argTypes: seq[NimNode], - hasReturnValue, isStaticCall: static[bool]): typed = + hasReturnValue, isStaticCall: static[bool]): untyped = ## Produces statement in form: ## ## .. code-block:: nim @@ -287,7 +286,7 @@ macro invokeVarArgs(procIdent, objIdent; " arguments, but got " & $numArgs) result.add(newNimNode(nnkElse).add(getAst( - printInvokeErr($procIdent.ident, minArgs, maxArgs, numArgsIdent)))) + printInvokeErr(procIdent.strVal, minArgs, maxArgs, numArgsIdent)))) proc typeError(nimType: string, value: string, godotType: VariantType, className: cstring, propertyName: cstring): string = @@ -433,6 +432,73 @@ proc toGodotStyle(s: string): string {.compileTime.} = else: result.add(c) +proc checkReplaceSelfVar(node: NimNode, childIndex: int, varsList, propsList: seq[string]) {.compileTime.} = + let identName = node[childIndex].strVal + if varsList.binarySearch(identName) == -1 and propsList.binarySearch(identName) != -1: + var newChild = newDotExpr(ident("self"), node[childIndex]) + node.del childIndex + node.insert(childIndex, newChild) + +proc checkReplaceSelfMethod(node: NimNode, childIndex: int, methodsList: seq[string]) {.compileTime.} = + if methodsList.binarySearch(node[childIndex].strVal) != -1: + var newChild = newDotExpr(ident("self"), node[childIndex]) + node.del childIndex + node.insert(childIndex, newChild) + +proc applySelf(node: NimNode, varsList: ref seq[string], propsList, methodsList: seq[string]) {.compileTime.} = + var lowIndx = -1 + var highIndx = node.len - 1 + var isBlock: bool = false + case node.kind: + of nnkCommand, nnkCall: + if node[0].kind == nnkDotExpr: + lowIndx = 0 + elif node[0].kind == nnkIdent: + if node[0].strVal != "procCall": + checkReplaceSelfMethod(node, 0, methodsList) + lowIndx = 1 + else: + lowIndx = 1 + of nnkInfix..nnkPostfix, nnkExprColonExpr, nnkObjConstr, nnkCast: + lowIndx = 1 + of nnkExprEqExpr, nnkPar, nnkCurly..nnkBracketExpr, nnkRange, nnkDerefExpr, nnkIfExpr, nnkTableConstr, nnkAddr, nnkAsgn, + nnkIfStmt, nnkCaseStmt, nnkVarSection, nnkLetSection, nnkConstSection, nnkDefer, nnkRaiseStmt, nnkReturnStmt, nnkStmtList, + nnkStmtListExpr, nnkTupleConstr: + lowIndx = 0 + of nnkIdentDefs: + lowIndx = 2 + if node[0].kind == nnkIdent: + let index = lowerBound(varsList[], node[0].strVal) + varsList[].insert(node[0].strVal, index) + of nnkVarTuple: + lowIndx = node.len - 1 + for i in 0..node.len - 3: + if node[i].kind == nnkIdent: + let index = lowerBound(varsList[], node[i].strVal) + varsList[].insert(node[i].strVal, index) + of nnkDotExpr: + lowIndx = 0 + highIndx = 0 + of nnkElifExpr, nnkElseExpr, nnkOfBranch..nnkElse, nnkWhenStmt..nnkWhileStmt, nnkTryStmt, nnkFinally, nnkBlockStmt, nnkBlockExpr: + isBlock = true + lowIndx = 0 + of nnkConstDef: + if node[0].kind == nnkIdent: + let index = lowerBound(varsList[], node[0].strVal) + varsList[].insert(node[0].strVal, index) + else: + discard + if lowIndx != -1: + var nodeVars = varsList + for i in lowIndx..highIndx: + if isBlock and i == highIndx: + new(nodeVars) + nodeVars[] = varsList[] + if node[i].kind == nnkIdent: + checkReplaceSelfVar(node, i, nodeVars[], propsList) + else: + applySelf(node[i], nodeVars, propsList, methodsList) + proc genType(obj: ObjectDecl): NimNode {.compileTime.} = result = newNimNode(nnkStmtList) @@ -480,11 +546,6 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = else: initMethod.body.insert(0, initBody) - # {.this: self.} for convenience - result.add(newNimNode(nnkPragma).add(newNimNode(nnkExprColonExpr).add( - ident("this"), ident("self") - ))) - # Nim proc defintions var decls = newSeqOfCap[NimNode](obj.methods.len) for meth in obj.methods: @@ -539,6 +600,25 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = genSym(nskProc, "getFunc"), newStrLitNode(hintStr), hintIdent, usage, ident($hasDefaultValue), field.defaultValue))) + + # Keep track of object's fields and methods (used instead of deprecated this:self pragma) + var propsList: seq[string] = @[] + for field in obj.fields: + let indx = lowerBound(propsList, field.name.strVal) + propsList.insert(field.name.strVal, indx) + var methodsList: seq[string] = @[] + for meth in obj.methods: + let indx = lowerBound(methodsList, meth.name) + methodsList.insert(meth.name, indx) + + # Inject self to properties and methods + for meth in obj.methods: + let varsList = new(seq[string]) + for v in meth.nimNode[3]: + if v.kind == nnkIdentDefs: + varsList[].add v[0].strVal + applySelf(meth.nimNode[6], varsList, propsList, methodsList) + # Register methods template registerGodotMethod(classNameLit, classNameIdent, methodNameIdent, @@ -604,7 +684,7 @@ N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); let hasReturnValueBool = not (meth.returnType.isNil or meth.returnType.kind == nnkEmpty or (meth.returnType.kind == nnkIdent and - meth.returnType.ident == toNimIdent("void"))) + meth.returnType.strVal == "void")) let hasReturnValue = if hasReturnValueBool: ident("true") else: ident("false") result.add(getAst( @@ -630,11 +710,7 @@ N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); GodotMethodAttributes(), refDec) result.add(getAst(registerRefIncDec(classNameLit))) -{.push warning[Deprecated]: off.} -# immediate macros are deprecated, but `untyped` doesn't make it immediate, -# as the warning and the documentation claim. - -macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = +macro gdobj*(ast: varargs[untyped]): untyped = ## Generates Godot type. Self-documenting example: ## ## .. code-block:: nim @@ -678,7 +754,7 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} = ## `gdnew `_ or by using ## `load `_ or any other way ## that you can find in `Godot API `_. - let typeDef = parseType(definition, callsite()) + let typeDef = parseType(ast) result = genType(typeDef) -{.push warning[Deprecated]: on.} + diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index e58c330..1361450 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -2,13 +2,13 @@ import tables, typetraits, macros, unicode, strutils, sets import gdnativeapi -import core.godotcoretypes, core.godotbase -import core.vector2, core.rect2, - core.vector3, core.transform2d, - core.planes, core.quats, core.aabb, - core.basis, core.transforms, core.colors, - core.nodepaths, core.rids, core.dictionaries, - core.arrays, core.poolarrays, core.variants +import core/godotcoretypes, core/godotbase +import core/vector2, core/rect2, + core/vector3, core/transform2d, + core/planes, core/quats, core/aabb, + core/basis, core/transforms, core/colors, + core/nodepaths, core/rids, core/dictionaries, + core/arrays, core/poolarrays, core/variants import godotinternal ## This module defines ``NimGodotObject`` and ``toVariant``/``fromVariant`` @@ -343,20 +343,20 @@ proc newRStrLit(s: string): NimNode {.compileTime.} = result = newNimNode(nnkRStrLit) result.strVal = s -macro toGodotName(T: typedesc): string = +macro toGodotName(T: typedesc): untyped = if T is GodotString or T is string: - "String" + newStrLitNode"String" elif T is SomeFloat: - "float" + newStrLitNode"float" elif T is SomeUnsignedInt or T is SomeSignedInt: - "int" + newStrLitNode"int" else: - let nameStr = (($T.getType()[1][1].symbol).split(':')[0]) + let nameStr = ((T.getType()[1][1].strVal).split(':')[0]) case nameStr: of "File", "Directory", "Thread", "Mutex", "Semaphore": - "_" & nameStr + newStrLitNode("_" & nameStr) else: - nameStr + newStrLitNode(nameStr) macro asCString(s: static[string]): cstring = result = newNimNode(nnkCallStrLit).add( diff --git a/godot/nim/nim.cfg b/godot/nim/nim.cfg index f1fb6a7..1f12860 100644 --- a/godot/nim/nim.cfg +++ b/godot/nim/nim.cfg @@ -1 +1,2 @@ ---path:"$projectdir/../" \ No newline at end of file +--path:"$projectdir/../" +-d:userealtimeGC \ No newline at end of file From 19b0c23d6223e448d512d6637531b53e943f76e7 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Sun, 15 Sep 2019 15:39:10 +0700 Subject: [PATCH 142/160] Finalize support for Nim 0.20 Closes #32, closes #41. --- godot.nimble | 2 +- godot/core/godotbase.nim | 15 ++-- godot/godotapigen.nim | 18 ++-- godot/internal/backwardcompat.inc.nim | 19 +++++ godot/internal/godotstrings.nim | 8 +- godot/nim/godotmacros.nim | 116 ++++---------------------- godot/nim/godotnim.nim | 42 +++++----- godot/nim/nim.cfg | 2 +- 8 files changed, 91 insertions(+), 131 deletions(-) create mode 100644 godot/internal/backwardcompat.inc.nim diff --git a/godot.nimble b/godot.nimble index 66794fc..c5472c9 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.20" +version = "0.7.21" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/godotbase.nim b/godot/core/godotbase.nim index d76f544..7b5b804 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -30,14 +30,17 @@ proc stepify*(value, step: float32): float32 {.inline, noinit.} = else: value -proc min*(x, y: float32): float32 {.inline, noinit.} = - if x <= y: x else: y +when (NimMajor, NimMinor, NimPatch) < (0, 20, 4): + # Newer Nim has these procs in system module -proc abs*(x: float32): float32 {.inline, noinit.} = - if x < 0.0: -x else: x + proc min*(x, y: float32): float32 {.inline, noinit.} = + if x <= y: x else: y -proc max*(x, y: float32): float32 {.inline, noinit.} = - if y <= x: x else: y + proc abs*(x: float32): float32 {.inline, noinit.} = + if x < 0.0: -x else: x + + proc max*(x, y: float32): float32 {.inline, noinit.} = + if y <= x: x else: y {.pop.} # stackTrace: off diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index a53ee6f..ca0dfaf 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -2,7 +2,12 @@ import streams, json, os, strutils, times, sets, tables, options import sequtils, algorithm -import compiler/ast, compiler/renderer, compiler/idents, compiler/astalgo, compiler/lineinfos +import compiler/ast, compiler/renderer, compiler/idents, compiler/astalgo + +include "internal/backwardcompat.inc.nim" + +when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0): + import compiler/lineinfos when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0): var gic = newIdentCache() @@ -14,10 +19,13 @@ proc ident(ident: string): PNode = result = PNode(kind: nkIdent, ident: getIdent(ident)) proc newPNode(kind: TNodeKind): PNode = - result = PNode(kind: kind) - result.info.fileIndex = InvalidFileIdx - result.info.col = int16(-1) - result.info.line = uint16(0) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + result = newNode(kind) + else: + result = PNode(kind: kind) + result.info.fileIndex = InvalidFileIdx + result.info.col = int16(-1) + result.info.line = uint16(0) proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} = for other in others: diff --git a/godot/internal/backwardcompat.inc.nim b/godot/internal/backwardcompat.inc.nim new file mode 100644 index 0000000..9d31844 --- /dev/null +++ b/godot/internal/backwardcompat.inc.nim @@ -0,0 +1,19 @@ +# Copyright 2019 Xored Software, Inc. + +when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + import macros, sets + + proc strVal(n: NimNode): string {.used.} = + case n.kind + of nnkIdent: + $n.ident + of nnkSym: + $n.symbol + else: + macros.strVal(n) + + proc toHashSet[A](keys: openArray[A]): HashSet[A] {.inline, used.} = + toSet(keys) + + proc initHashSet[A](): HashSet[A] {.inline, used.} = + initSet[A]() diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index 18bcf63..e67acfd 100644 --- a/godot/internal/godotstrings.nim +++ b/godot/internal/godotstrings.nim @@ -38,7 +38,13 @@ proc `$`*(self: GodotString): string = proc toGodotString*(s: string): GodotString {.inline.} = ## Converts the Nim string into ``GodotString`` - initGodotString(result, cstring(s), cint(s.len + 1)) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + if s.isNil: + initGodotString(result) + else: + initGodotString(result, cstring(s), cint(s.len + 1)) + else: + initGodotString(result, cstring(s), cint(s.len + 1)) proc toGodotString*(s: cstring): GodotString {.inline.} = ## Converts the cstring into ``GodotString`` diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index f6a613a..90e9ea7 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -32,6 +32,8 @@ type ParseError = object of Exception +include "internal/backwardcompat.inc.nim" + proc godotToNim[T](val: Variant): (T, ConversionResult) = mixin fromVariant result[1] = fromVariant(result[0], val) @@ -432,73 +434,6 @@ proc toGodotStyle(s: string): string {.compileTime.} = else: result.add(c) -proc checkReplaceSelfVar(node: NimNode, childIndex: int, varsList, propsList: seq[string]) {.compileTime.} = - let identName = node[childIndex].strVal - if varsList.binarySearch(identName) == -1 and propsList.binarySearch(identName) != -1: - var newChild = newDotExpr(ident("self"), node[childIndex]) - node.del childIndex - node.insert(childIndex, newChild) - -proc checkReplaceSelfMethod(node: NimNode, childIndex: int, methodsList: seq[string]) {.compileTime.} = - if methodsList.binarySearch(node[childIndex].strVal) != -1: - var newChild = newDotExpr(ident("self"), node[childIndex]) - node.del childIndex - node.insert(childIndex, newChild) - -proc applySelf(node: NimNode, varsList: ref seq[string], propsList, methodsList: seq[string]) {.compileTime.} = - var lowIndx = -1 - var highIndx = node.len - 1 - var isBlock: bool = false - case node.kind: - of nnkCommand, nnkCall: - if node[0].kind == nnkDotExpr: - lowIndx = 0 - elif node[0].kind == nnkIdent: - if node[0].strVal != "procCall": - checkReplaceSelfMethod(node, 0, methodsList) - lowIndx = 1 - else: - lowIndx = 1 - of nnkInfix..nnkPostfix, nnkExprColonExpr, nnkObjConstr, nnkCast: - lowIndx = 1 - of nnkExprEqExpr, nnkPar, nnkCurly..nnkBracketExpr, nnkRange, nnkDerefExpr, nnkIfExpr, nnkTableConstr, nnkAddr, nnkAsgn, - nnkIfStmt, nnkCaseStmt, nnkVarSection, nnkLetSection, nnkConstSection, nnkDefer, nnkRaiseStmt, nnkReturnStmt, nnkStmtList, - nnkStmtListExpr, nnkTupleConstr: - lowIndx = 0 - of nnkIdentDefs: - lowIndx = 2 - if node[0].kind == nnkIdent: - let index = lowerBound(varsList[], node[0].strVal) - varsList[].insert(node[0].strVal, index) - of nnkVarTuple: - lowIndx = node.len - 1 - for i in 0..node.len - 3: - if node[i].kind == nnkIdent: - let index = lowerBound(varsList[], node[i].strVal) - varsList[].insert(node[i].strVal, index) - of nnkDotExpr: - lowIndx = 0 - highIndx = 0 - of nnkElifExpr, nnkElseExpr, nnkOfBranch..nnkElse, nnkWhenStmt..nnkWhileStmt, nnkTryStmt, nnkFinally, nnkBlockStmt, nnkBlockExpr: - isBlock = true - lowIndx = 0 - of nnkConstDef: - if node[0].kind == nnkIdent: - let index = lowerBound(varsList[], node[0].strVal) - varsList[].insert(node[0].strVal, index) - else: - discard - if lowIndx != -1: - var nodeVars = varsList - for i in lowIndx..highIndx: - if isBlock and i == highIndx: - new(nodeVars) - nodeVars[] = varsList[] - if node[i].kind == nnkIdent: - checkReplaceSelfVar(node, i, nodeVars[], propsList) - else: - applySelf(node[i], nodeVars, propsList, methodsList) - proc genType(obj: ObjectDecl): NimNode {.compileTime.} = result = newNimNode(nnkStmtList) @@ -546,6 +481,12 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = else: initMethod.body.insert(0, initBody) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + # {.this: self.} for convenience + result.add(newNimNode(nnkPragma).add(newNimNode(nnkExprColonExpr).add( + ident("this"), ident("self") + ))) + # Nim proc defintions var decls = newSeqOfCap[NimNode](obj.methods.len) for meth in obj.methods: @@ -600,25 +541,6 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = genSym(nskProc, "getFunc"), newStrLitNode(hintStr), hintIdent, usage, ident($hasDefaultValue), field.defaultValue))) - - # Keep track of object's fields and methods (used instead of deprecated this:self pragma) - var propsList: seq[string] = @[] - for field in obj.fields: - let indx = lowerBound(propsList, field.name.strVal) - propsList.insert(field.name.strVal, indx) - var methodsList: seq[string] = @[] - for meth in obj.methods: - let indx = lowerBound(methodsList, meth.name) - methodsList.insert(meth.name, indx) - - # Inject self to properties and methods - for meth in obj.methods: - let varsList = new(seq[string]) - for v in meth.nimNode[3]: - if v.kind == nnkIdentDefs: - varsList[].add v[0].strVal - applySelf(meth.nimNode[6], varsList, propsList, methodsList) - # Register methods template registerGodotMethod(classNameLit, classNameIdent, methodNameIdent, @@ -627,10 +549,6 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): {.emit: """/*TYPESECTION*/ N_NOINLINE(void, setStackBottom)(void* thestackbottom); -""".} - else: - {.emit: """ -N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); """.} proc methFuncIdent(obj: ptr GodotObject, methodData: pointer, @@ -638,9 +556,13 @@ N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); args: var array[MAX_ARG_COUNT, ptr GodotVariant]): GodotVariant {.noconv.} = var stackBottom {.volatile.}: pointer - {.emit: """ - nimGC_setStackBottom((void*)(&`stackBottom`)); - """.} + stackBottom = addr(stackBottom) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + {.emit: """ + setStackBottom((void*)(&`stackBottom`)); + """.} + else: + nimGC_setStackBottom(stackBottom) let self = cast[classNameIdent](userData) const isStaticCall = methodNameLit == cstring"_ready" or methodNameLit == cstring"_process" or @@ -718,7 +640,7 @@ macro gdobj*(ast: varargs[untyped]): untyped = ## ## gdobj MyObj of Node: ## var myField: int - ## ## Not exported to Godot (i.e. editor will not see this field). + ## ## Not exported to Godot (i.e. editor and scripts will not see this field). ## ## var myString* {.gdExport, hint: Length, hintStr: "20".}: string ## ## Exported to Godot as ``my_string``. @@ -731,12 +653,12 @@ macro gdobj*(ast: varargs[untyped]): untyped = ## ## Exported methods are exported to Godot by default, ## ## and their Godot names are prefixed with ``_`` ## ## (in this case ``_ready``) - ## print("I am ready! myString is: " & myString) + ## print("I am ready! myString is: " & self.myString) ## ## proc myProc*() {.gdExport.} = ## ## Exported to Godot as ``my_proc`` ## print("myProc is called! Incrementing myField.") - ## inc myField + ## inc self.myField ## ## If parent type is omitted, the type is inherited from ``Object``. ## @@ -756,5 +678,3 @@ macro gdobj*(ast: varargs[untyped]): untyped = ## that you can find in `Godot API `_. let typeDef = parseType(ast) result = genType(typeDef) - - diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 1361450..bba8b98 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -91,6 +91,8 @@ type FNV1Hash = uint32 +include "internal/backwardcompat.inc.nim" + proc isFinalized*(obj: NimGodotObject): bool {.inline.} = obj.isFinalized @@ -110,13 +112,13 @@ template initFNV1Hash(hash: var FNV1Hash) = template appendFNV1Hash(hash: var FNV1Hash, val: uint8) = block: let u64hash = hash.uint64 - hash = ( + hash = (( u64hash + (u64hash shl 1'u64) + (u64hash shl 4'u64) + (u64hash shl 7'u64) + (u64hash shl 8'u64) + - (u64hash shl 24'u64)).uint32 xor val + (u64hash shl 24'u64)) and 0xFFFFFFFF'u32).uint32 xor val {.push stackTrace:off.} proc lsb(c: ptr cwchar_t): char {.noinit, inline.} = @@ -187,7 +189,7 @@ proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) = if obj.godotObject.isNil or obj.isNative: return # important to set it before so that ``unreference`` is aware obj.isFinalized = true - if (obj.isRef or not obj.linkedObject.isNil and obj.linkedObject.isRef) and + if (obj.isRef or not obj.linkedObject.isNil and obj.linkedObject.isRef) and obj.godotObject.unreference(): obj.deinit() @@ -708,16 +710,13 @@ proc toVariant*(s: string): Variant {.inline.} = proc fromVariant*(s: var string, val: Variant): ConversionResult = if val.getType() == VariantType.String: s = val.asString() - when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): - if val.getType() == VariantType.Nil: + elif val.getType() == VariantType.Nil: + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): s = nil else: - result = ConversionResult.TypeError - else: - if val.getType() == VariantType.Nil: s = "" - else: - result = ConversionResult.TypeError + else: + result = ConversionResult.TypeError template arrTypeInfo(T) = result.variantType = VariantType.Array @@ -840,11 +839,6 @@ when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): N_LIB_EXPORT N_CDECL(void, NimMain)(void); N_NOINLINE(void, setStackBottom)(void* thestackbottom); """.} -else: - {.emit: """/*TYPESECTION*/ - N_LIB_EXPORT N_CDECL(void, NimMain)(void); - N_NOINLINE(void, nimGC_setStackBottom)(void* thestackbottom); - """.} var nativeLibHandle: pointer proc getNativeLibHandle*(): pointer = @@ -857,10 +851,16 @@ proc godot_nativescript_init(handle: pointer) {. nativeLibHandle = handle var stackBottom {.volatile.}: pointer + stackBottom = addr(stackBottom) {.emit: """ NimMain(); - nimGC_setStackBottom((void*)(&`stackBottom`)); """.} + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + {.emit: """ + setStackBottom((void*)(&`stackBottom`)); + """.} + else: + nimGC_setStackBottom(stackBottom) GC_fullCollect() GC_disable() @@ -896,9 +896,13 @@ proc registerFrameCallback*(cb: proc () {.closure.}) = proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = var stackBottom {.volatile.}: pointer - {.emit: """ - nimGC_setStackBottom((void*)(&`stackBottom`)); - """.} + stackBottom = addr(stackBottom) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + {.emit: """ + setStackBottom((void*)(&`stackBottom`)); + """.} + else: + nimGC_setStackBottom(stackBottom) for cb in idleCallbacks: cb() GC_step(nimGcStepLengthUs, true, 0) diff --git a/godot/nim/nim.cfg b/godot/nim/nim.cfg index 1f12860..add9a4d 100644 --- a/godot/nim/nim.cfg +++ b/godot/nim/nim.cfg @@ -1,2 +1,2 @@ --path:"$projectdir/../" --d:userealtimeGC \ No newline at end of file +-d:useRealtimeGc \ No newline at end of file From 2f3f4034cfd8d532efea88d15b62e39af67419e2 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 18 Sep 2019 13:27:31 +0700 Subject: [PATCH 143/160] Fix newVariant for nil strings and older Nim --- godot.nimble | 2 +- godot/core/variants.nim | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index c5472c9..71cfda5 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.21" +version = "0.7.22" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/core/variants.nim b/godot/core/variants.nim index ce1d945..fcb2b04 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -73,6 +73,10 @@ proc newVariant*(r: cdouble): Variant {.inline.} = proc newVariant*(s: string): Variant {.inline.} = new(result, variantFinalizer) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + if s.isNil: + initGodotVariant(result.godotVariant) + return var godotStr = s.toGodotString() initGodotVariant(result.godotVariant, godotStr) godotStr.deinit() From 7dd1b1ed5f0c2fedfc23b31ed7593c57515c8c66 Mon Sep 17 00:00:00 2001 From: Dwana Games Date: Thu, 19 Sep 2019 14:14:58 -0500 Subject: [PATCH 144/160] Add self to field initialization --- godot/nim/godotmacros.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index 90e9ea7..c0a23cc 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -455,7 +455,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = let initBody = newStmtList() for decl in obj.fields: if not decl.defaultValue.isNil and decl.defaultValue.kind != nnkEmpty: - initBody.add(newNimNode(nnkAsgn).add(decl.name, decl.defaultValue)) + initBody.add(newNimNode(nnkAsgn).add(newDotExpr(ident("self"), decl.name), decl.defaultValue)) let name = if not decl.isExported: decl.name else: postfix(decl.name, "*") recList.add(newIdentDefs(name, decl.typ)) From c2db807da4bbc68fb7a70d4feb77b1575e869e53 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 20 Sep 2019 09:20:50 +0700 Subject: [PATCH 145/160] Up version to 0.7.23 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 71cfda5..1fdeeeb 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.22" +version = "0.7.23" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From 1b8e7ccd983e26f0838696ca7c7fe4df2282ae3d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 2 Oct 2019 15:26:41 +0700 Subject: [PATCH 146/160] Add variant conversion for Option[T] --- godot.nimble | 2 +- godot/nim/godotnim.nim | 23 ++++++++++++++++++++++- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index 1fdeeeb..6b77ece 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.23" +version = "0.7.24" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index bba8b98..cf989dc 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,6 +1,6 @@ # Copyright 2018 Xored Software, Inc. -import tables, typetraits, macros, unicode, strutils, sets +import tables, typetraits, macros, unicode, strutils, sets, options import gdnativeapi import core/godotcoretypes, core/godotbase import core/vector2, core/rect2, @@ -788,6 +788,27 @@ proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult = else: result = ConversionResult.TypeError +proc godotTypeInfo*[T](OptT: typedesc[Option[T]]): GodotTypeInfo = + when compiles(godotTypeInfo(T)): + result.variantType = godotTypeInfo(T) + else: + result.variantType = VariantType.Nil + +proc toVariant*[T](option: Option[T]): Variant = + if option.isSome(): + result = toVariant(option.unsafeGet()) + else: + result = newVariant() + +proc fromVariant*[T](option: var Option[T], val: Variant): ConversionResult = + if val.getType() == VariantType.Nil: + option = none(T) + else: + var v: T + result = fromVariant(v, val) + if result == ConversionResult.OK: + option = some(result) + proc godotTypeInfo*(T: typedesc[Table|TableRef|OrderedTable|OrderedTableRef]): GodotTypeInfo {.inline.} = result.variantType = VariantType.Dictionary From 78d3626fa36c5749e098fa32086c34a39a6ad81e Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 4 Dec 2019 23:58:13 +0700 Subject: [PATCH 147/160] Do not log error when casting fails This allows not to perform unnecessary 'of' check before casting, if cast failure is expected. --- godot.nimble | 2 +- godot/nim/godotnim.nim | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/godot.nimble b/godot.nimble index 6b77ece..1ad646b 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.24" +version = "0.7.25" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index cf989dc..4d577cc 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -332,9 +332,6 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = elif not obj.linkedObject.isNil and system.`of`(obj.linkedObject, T): result = T(obj.linkedObject) else: - when not defined(release): - printError("Failed to cast object to " & - T.name & "\n" & getStackTrace()) result = nil proc `of`*[T1, T2: NimGodotObject](obj: T1, t: typedesc[T2]): bool {.inline.} = From d1b82d351c81243670694e6f79d584ac7b837106 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 23 Dec 2019 20:53:13 +0700 Subject: [PATCH 148/160] Fix unsigned int conversion to/from Variant --- godot.nimble | 2 +- godot/nim/godotnim.nim | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/godot.nimble b/godot.nimble index 1ad646b..7115536 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.25" +version = "0.7.26" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 4d577cc..7b0a832 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -604,7 +604,11 @@ proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt]( else: uint64) intVal = when T is SomeSignedInt: val.asInt() else: val.asUint() - if intVal > high(T) or intVal < low(T): + const highT = when T is SomeSignedInt: high(T).int64 + else: high(T).uint64 + const lowT = when T is SomeSignedInt: low(T).int64 + else: low(T).uint64 + if intVal > highT or intVal < lowT: result = ConversionResult.RangeError else: self = T(intVal) From 157a90e4a0bd82a91f8ab34cd1154e0b9869ae48 Mon Sep 17 00:00:00 2001 From: zetashift Date: Wed, 5 Feb 2020 05:35:50 +0100 Subject: [PATCH 149/160] add gensym in hygienic template fix thanks to demotohiro (#55) Add gensym in hygienic template fix thanks to demotohiro --- godot/nim/godotmacros.nim | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index c0a23cc..c4715c3 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -396,10 +396,9 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit, getFunc: getFuncIdent ) mixin godotTypeInfo - static: - var typeInfo: GodotTypeInfo - when compiles(godotTypeInfo(propTypeIdent)): - typeInfo = godotTypeInfo(propTypeIdent) + const typeInfo = when compiles(godotTypeInfo(propTypeIdent)): + godotTypeInfo(propTypeIdent) + else: GodotTypeInfo() const hintStr = when hintStrLit != "NIM": hintStrLit else: @@ -455,7 +454,8 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} = let initBody = newStmtList() for decl in obj.fields: if not decl.defaultValue.isNil and decl.defaultValue.kind != nnkEmpty: - initBody.add(newNimNode(nnkAsgn).add(newDotExpr(ident("self"), decl.name), decl.defaultValue)) + initBody.add(newNimNode(nnkAsgn).add(newDotExpr(ident("self"), decl.name), + decl.defaultValue)) let name = if not decl.isExported: decl.name else: postfix(decl.name, "*") recList.add(newIdentDefs(name, decl.typ)) @@ -605,7 +605,7 @@ N_NOINLINE(void, setStackBottom)(void* thestackbottom); else: toGodotStyle(meth.name) let hasReturnValueBool = not (meth.returnType.isNil or meth.returnType.kind == nnkEmpty or - (meth.returnType.kind == nnkIdent and + (meth.returnType.kind == nnkIdent and meth.returnType.strVal == "void")) let hasReturnValue = if hasReturnValueBool: ident("true") else: ident("false") From a49fcbdac7da28bb9af40f1a12ff87ca656102ed Mon Sep 17 00:00:00 2001 From: Konstantin Zaitsev Date: Wed, 5 Feb 2020 10:30:04 +0700 Subject: [PATCH 150/160] Fix variant size for 32bit platform with memory alignment --- godot/internal/godotinternaltypes.nim | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/godot/internal/godotinternaltypes.nim b/godot/internal/godotinternaltypes.nim index 8474af8..a2910c9 100644 --- a/godot/internal/godotinternaltypes.nim +++ b/godot/internal/godotinternaltypes.nim @@ -116,7 +116,8 @@ type expected*: VariantType GodotVariant* {.byref.} = object - data: array[4 + sizeof(int) div 4, float32] + data: array[2, int64] + data2: int type GodotMethodBind* = object From ed9ede5cb357022d18bd6fdb326c76aa3eb3b92d Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 5 Feb 2020 12:34:44 +0700 Subject: [PATCH 151/160] Up version to 0.7.27 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 7115536..6d35312 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.26" +version = "0.7.27" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" From 031774f54f1ee88d9a88e8be0a255c3a590c58fd Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 3 Jun 2020 15:52:11 +0700 Subject: [PATCH 152/160] More efficient and GC-safe conversions in API generator --- godot.nimble | 2 +- godot/godotapigen.nim | 66 ++++++++++++++++++++++++++++++++------- godot/nim/godotmacros.nim | 6 +++- 3 files changed, 61 insertions(+), 13 deletions(-) diff --git a/godot.nimble b/godot.nimble index 6d35312..f511b3f 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.27" +version = "0.7.28" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index ca0dfaf..432814e 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -308,6 +308,13 @@ const standardTypes = toHashSet( "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray"]) +const variantPrimitives = [ + "bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", + "uint64", "Error", + "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", + "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", + "Color", "RID"] + const smallIntTypes = toHashSet(["uint8", "int8", "uint16", "int16", "uint32", "int32", "cint", "int", "Error"]) const int64Types = toHashSet(["uint64", "int64"]) @@ -322,7 +329,7 @@ const wrapperTypes = union(arrayTypes, toHashSet(["NodePath", "Dictionary", "Variant"])) proc getInternalPtr(varName: PNode, typ: string): PNode = - assert(typ in wrapperTypes) + assert(typ in wrapperTypes or typ == "Object") result = newDotExpr(varName, ident("godot" & typ)) proc newNilCheck(ident, toAssign: PNode): PNode = @@ -479,7 +486,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], ident("+"), newDotExpr(ident(varargsName.get), ident("len")))) argsAlloc.add(newCall("godotAlloc", newCall("cint", infix( - newCall("sizeof", ident("Variant")), ident("*"), + newCall("sizeof", newPNode(nkPtrTy).addChain(ident("GodotVariant"))), ident("*"), newPNode(nkPar).addChain(argLenNode)))) ) else: @@ -493,6 +500,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], vars.add(newIdentDefs(argsName, newPNode(nkEmpty), argsAlloc)) let argConversions = newPNode(nkStmtList) + let destructors = newPNode(nkStmtList) for idx, arg in meth.args: var argName = if arg.kind == ArgKind.Bound: ident(boundArgName(idx)) else: ident(arg.name) @@ -503,13 +511,48 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], let argIdx = if arg.kind == ArgKind.VarArgs: ident("idx") else: newIntLit(idx) let isStandardType = arg.typ in standardTypes let isWrappedType = arg.typ in wrapperTypes - let convArg = if varargsName.isSome: - getInternalPtr(newCall("toVariant", argName), "Variant") - elif isWrappedType: getInternalPtr(argName, arg.typ) - elif isStandardType: newCall("unsafeAddr", argName) - elif arg.typ == "string": newCall("unsafeAddr", - ident("argToPassToGodot" & $idx)) - else: ident("argToPassToGodot" & $idx) # object + let convArg = + if varargsName.isSome: + let isAlreadyVariant = arg.typ == "Variant" + let variantIdent = if isAlreadyVariant: getInternalPtr(argName, "Variant") + else: ident("variant" & $idx) + if not isAlreadyVariant: + argConversions.add(newPNode(nkVarSection).addChain( + newIdentDefs(variantIdent, ident("GodotVariant"), newEmptyNode()) + )) + destructors.add( + newCall("deinit", variantIdent) + ) + if arg.typ in variantPrimitives: + argConversions.add( + newCall("initGodotVariant", variantIdent, argName) + ) + elif arg.typ in wrapperTypes or arg.typ == "Object": + argConversions.add( + newCall("initGodotVariant", variantIdent, getInternalPtr(argName, arg.typ)) + ) + elif arg.typ == "string": + let stringIdent = ident("variantString" & $idx) + argConversions.addChain( + newPNode(nkVarSection).addChain( + newIdentDefs(stringIdent, ident("GodotString"), newCall("toGodotString", argName)) + ) + ).addChain( + newCall("initGodotVariant", variantIdent, stringIdent) + ) + destructors.add(newCall("deinit", stringIdent)) + else: + raise newException(ValueError, + "Non-standard type $# for varargs params of method $# of type $#" % + [arg.typ, meth.godotName, meth.typ.godotName]) + + if isAlreadyVariant: variantIdent + else: newCall("addr", variantIdent) + elif isWrappedType: getInternalPtr(argName, arg.typ) + elif isStandardType: newCall("unsafeAddr", argName) + elif arg.typ == "string": newCall("unsafeAddr", + ident("argToPassToGodot" & $idx)) + else: ident("argToPassToGodot" & $idx) # object if not isStandardType and arg.kind == ArgKind.VarArgs: raise newException(ValueError, "Non-standard type $# for varargs params of method $# of type $#" % @@ -630,9 +673,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], if arg.typ == "string": body.add(newCall("deinit", ident("argToPassToGodot" & $idx))) - if meth.args.len > 0 and varargsName.isSome: - body.add(freeCall) if varargsName.isSome: + if meth.args.len > 0: + body.add(freeCall) + body.add(destructors) let errCheck = newIfStmt( infix(newDotExpr(ident("callError"), ident("error")), ident("!="), newDotExpr(ident("VariantCallErrorType"), ident("OK"))), diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index c4715c3..d6efa6d 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -272,8 +272,12 @@ macro invokeVarArgs(procIdent, objIdent; invocation = newNimNode(nnkCall).add(ident("procCall"), invocation) if hasReturnValue: + let resultVariant = genSym(nskLet, "ret") + branchBody.add( + newNimNode(nnkLetSection).add( + newIdentDefs(resultVariant, ident("Variant"), newCall("toVariant", invocation)))) let theCall = newNimNode(nnkBracketExpr).add(newNimNode(nnkDotExpr).add( - newCall("toVariant", invocation), ident("godotVariant"))) + resultVariant, ident("godotVariant"))) branchBody.add(getAst(initGodotVariantCall(ident("result"), theCall))) else: branchBody.add(invocation) From 87707a86b437371db4534884291d0e12c12036fa Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Wed, 3 Jun 2020 18:06:18 +0700 Subject: [PATCH 153/160] Remove Travis badge from README Need to fix the CI script. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 891a920..db27270 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Nim bindings for Godot Engine [![Build Status](https://travis-ci.org/pragmagic/godot-nim.svg?branch=master)](https://travis-ci.org/pragmagic/godot-nim) +# Nim bindings for Godot Engine Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here). From 3f46e3c6481e9f18041f3b4b7d018635ae36b819 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 5 Jun 2020 16:53:34 +0700 Subject: [PATCH 154/160] Break reference cycle in NimGodotObject --- godot.nimble | 2 +- godot/nim/godotnim.nim | 14 +++++++++++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/godot.nimble b/godot.nimble index f511b3f..817406d 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.7.28" +version = "0.8.0" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/nim/godotnim.nim b/godot/nim/godotnim.nim index 7b0a832..7f3ed96 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -31,7 +31,7 @@ type ## The base type all Godot types inherit from. ## Manages lifecycle of the wrapped ``GodotObject``. godotObject: ptr GodotObject - linkedObject: NimGodotObject + linkedObjectPtr: pointer ## Wrapper around native object that is the container of the Nim "script" ## This is needed for `of` checks and `as` conversions to work as ## expected. For example, Nim type may inherit from ``Spatial``, but the @@ -39,6 +39,8 @@ type ## ``Particles`` is valid, but Nim type system is not aware of that. ## This works in both directions - for linked native object this ## reference points to Nim object. + ## This is stored as a raw pointer to avoid reference cycles and therefore + ## improve GC performance. isRef*: bool isFinalized: bool isNative: bool @@ -185,6 +187,9 @@ proc deinit*(obj: NimGodotObject) = obj.godotObject.deinit() obj.godotObject = nil +proc linkedObject(obj: NimGodotObject): NimGodotObject {.inline.} = + cast[NimGodotObject](obj.linkedObjectPtr) + proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) = if obj.godotObject.isNil or obj.isNative: return # important to set it before so that ``unreference`` is aware @@ -465,14 +470,17 @@ proc setGodotObject*(nimObj: NimGodotObject, obj: ptr GodotObject) {.inline.} = proc setNativeObject*(nimObj: NimGodotObject, nativeObj: NimGodotObject) {.inline.} = ## Used from Godot constructor produced by ``gdobj`` macro. Do not call. - nimObj.linkedObject = nativeObj - nativeObj.linkedObject = nimObj + GC_ref(nativeObj) + nimObj.linkedObjectPtr = cast[pointer](nativeObj) + nativeObj.linkedObjectPtr = cast[pointer](nimObj) nativeObj.isNative = true proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} = ## Used from Godot destructor produced by ``gdobj`` macro. Do not call. + GC_unref(nimObj.linkedObject) nimObj.godotObject = nil nimObj.linkedObject.godotObject = nil + nimObj.linkedObjectPtr = nil proc `==`*(self, other: NimGodotObject): bool {.inline.} = ## Compares objects by referential equality. From d3e5f91b403cb1cabc3d2f298b2c6ffc994493e4 Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Fri, 14 Aug 2020 01:44:48 +0700 Subject: [PATCH 155/160] Fix wrapping methods with Array return types --- godot.nimble | 2 +- godot/godotapigen.nim | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index 817406d..a296063 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.8.0" +version = "0.8.1" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT" diff --git a/godot/godotapigen.nim b/godot/godotapigen.nim index 432814e..ccbcc6c 100644 --- a/godot/godotapigen.nim +++ b/godot/godotapigen.nim @@ -642,6 +642,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], body.add(newPNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("Godot" & returnType), ))) + if returnType != "NodePath": + body.add(newCall("initGodot" & returnType, retValIdent)) elif returnType in standardTypes: addrToAssign = newCall("addr", ident("result")) elif returnType == "string": From f25c3c7a5dbe2b6ac8e4a3407e5c03751658e401 Mon Sep 17 00:00:00 2001 From: ShalokShalom Date: Sun, 11 Oct 2020 23:17:11 +0200 Subject: [PATCH 156/160] Clarify version compability One guy in the chat just asked me, if this binding is for 3.0 only, or also for 3.2.3 --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index db27270..62e28d3 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Nim bindings for Godot Engine -Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here). +Nim bindings for Godot 3 based on [GDNative](https://godotengine.org/article/dlscript-here). Documentation: https://pragmagic.github.io/godot-nim/ @@ -13,4 +13,4 @@ Documentation: https://pragmagic.github.io/godot-nim/ This project is licensed under the MIT license. Read [LICENSE](LICENSE) file for details. -Copyright (c) 2018 Xored Software, Inc. \ No newline at end of file +Copyright (c) 2018 Xored Software, Inc. From 388bea92053593646518946f6abc1001aea77702 Mon Sep 17 00:00:00 2001 From: Arun Dilipan Date: Mon, 23 Nov 2020 11:29:03 -0500 Subject: [PATCH 157/160] Added moveToward for vectors. --- godot/core/vector2.nim | 12 ++++++++++++ godot/core/vector3.nim | 12 ++++++++++++ 2 files changed, 24 insertions(+) diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 01c0312..390f1f6 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -5,6 +5,8 @@ import math, godotbase, hashes import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi +const EPSILON = 0.00001'f32 + {.push stackTrace: off.} proc vec2*(): Vector2 {.inline, noinit.} = @@ -199,4 +201,14 @@ proc clamped*(self: Vector2; length: float32): Vector2 {.noinit.} = result /= len result *= length +proc moveToward*(vFrom, to: Vector2, delta: float32): Vector2 = + let + vd = to - vFrom + vLen = vd.length + + if vLen <= delta or vLen < EPSILON: + result = to + else: + result = vFrom + (vd / vLen) * delta + {.pop.} # stackTrace: off diff --git a/godot/core/vector3.nim b/godot/core/vector3.nim index 16f2f04..ed2903a 100644 --- a/godot/core/vector3.nim +++ b/godot/core/vector3.nim @@ -3,6 +3,8 @@ import math, hashes import godotbase, godotcoretypes +const EPSILON = 0.00001'f32 + {.push stackTrace: off.} proc vec3*(): Vector3 {.inline.} = @@ -239,4 +241,14 @@ proc cubicInterpolate*(self, b, preA, postB: Vector3; (2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3) +proc moveToward*(vFrom, to: Vector3, delta: float32): Vector3 = + let + vd = to - vFrom + vLen = vd.length + + if vLen <= delta or vLen < EPSILON: + result = to + else: + result = vFrom + (vd / vLen) * delta + {.pop.} # stackTrace: off \ No newline at end of file From 00d8ac2691140edc610245fa56f28abea6572ec5 Mon Sep 17 00:00:00 2001 From: Jason Date: Tue, 9 Mar 2021 01:57:51 -0700 Subject: [PATCH 158/160] Support nim case insensitivy in pragmas --- godot/nim/godotmacros.nim | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index d6efa6d..6b81f7e 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -94,7 +94,7 @@ proc removePragmaNode(statement: NimNode, var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma() else: statement[1] for ident, val, i in pragmas(pragmas): - if ident == pname: + if ident.eqIdent(pname): pragmas.del(i) return val @@ -106,7 +106,7 @@ proc removePragma(statement: NimNode, pname: string): bool = var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma() else: statement[1] for ident, val, i in pragmas(pragmas): - if ident == pname: + if ident.eqIdent(pname): pragmas.del(i) return true From 7eadb07820a424c14a9474113ad3c0ee019c7334 Mon Sep 17 00:00:00 2001 From: Joey Date: Mon, 3 May 2021 10:01:38 -0600 Subject: [PATCH 159/160] Move template below arrays import Fixes #81 Alternate workaround for https://github.com/nim-lang/Nim/issues/16462 without changing VariantType. --- godot/core/poolarrays.nim | 48 +++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/godot/core/poolarrays.nim b/godot/core/poolarrays.nim index eac4cf4..29fda96 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -35,6 +35,30 @@ template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, (when type(item) is GodotString: ($item).hash() else: item.hash()) result = !$result +definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8, + godotPoolByteArray, newPoolByteArray, + initGodotPoolByteArray) +definePoolArrayBase(PoolIntArray, GodotPoolIntArray, cint, + godotPoolIntArray, newPoolIntArray, + initGodotPoolIntArray) +definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float32, + godotPoolRealArray, newPoolRealArray, + initGodotPoolRealArray) +definePoolArrayBase(PoolVector2Array, GodotPoolVector2Array, Vector2, + godotPoolVector2Array, newPoolVector2Array, + initGodotPoolVector2Array) +definePoolArrayBase(PoolVector3Array, GodotPoolVector3Array, Vector3, + godotPoolVector3Array, newPoolVector3Array, + initGodotPoolVector3Array) +definePoolArrayBase(PoolColorArray, GodotPoolColorArray, Color, + godotPoolColorArray, newPoolColorArray, + initGodotPoolColorArray) +definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string, + godotPoolStringArray, newPoolStringArray, + initGodotPoolStringArray) + +import arrays + template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; noData = false) = @@ -92,30 +116,6 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; for pair in arr.fieldName.mpairs: yield (pair[0].int, pair[1]) -definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8, - godotPoolByteArray, newPoolByteArray, - initGodotPoolByteArray) -definePoolArrayBase(PoolIntArray, GodotPoolIntArray, cint, - godotPoolIntArray, newPoolIntArray, - initGodotPoolIntArray) -definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float32, - godotPoolRealArray, newPoolRealArray, - initGodotPoolRealArray) -definePoolArrayBase(PoolVector2Array, GodotPoolVector2Array, Vector2, - godotPoolVector2Array, newPoolVector2Array, - initGodotPoolVector2Array) -definePoolArrayBase(PoolVector3Array, GodotPoolVector3Array, Vector3, - godotPoolVector3Array, newPoolVector3Array, - initGodotPoolVector3Array) -definePoolArrayBase(PoolColorArray, GodotPoolColorArray, Color, - godotPoolColorArray, newPoolColorArray, - initGodotPoolColorArray) -definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string, - godotPoolStringArray, newPoolStringArray, - initGodotPoolStringArray) - -import arrays - definePoolArray(PoolByteArray, GodotPoolByteArray, uint8, godotPoolByteArray, newPoolByteArray, initGodotPoolByteArray) From 4175dbb3e50d09341ae61cfa55907f40e9eb388b Mon Sep 17 00:00:00 2001 From: Ruslan Mustakov Date: Mon, 3 May 2021 23:18:50 +0700 Subject: [PATCH 160/160] Bump version to 0.8.2 --- godot.nimble | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/godot.nimble b/godot.nimble index a296063..d7ca12b 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.8.1" +version = "0.8.2" author = "Xored Software, Inc." description = "Godot Engine bindings" license = "MIT"