diff --git a/.travis.yml b/.travis.yml index 3dbd69a..b0b27d4 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 @@ -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 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..62e28d3 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ -# 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). +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) 2017 Xored Software, Inc. \ No newline at end of file +Copyright (c) 2018 Xored Software, Inc. diff --git a/docs/docbuild.nim b/docs/docbuild.nim index b48368d..477c45b 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 @@ -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) = @@ -94,7 +94,8 @@ 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 --path:godot -o:" & + quoted(outName(outDirAbs, file)) & " --git.url:" & quoted(gitHubUrl) & " --git.commit:" & quoted(gitCommit) & ' ' & quoted(file)) @@ -103,14 +104,15 @@ 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 --path:godot -o:" & + quoted(outName(godotApiFolder, file)) & ' ' & quoted(file)) sync() 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/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 320e99a..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,30 +33,16 @@ 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 ------------- -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. @@ -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. @@ -152,7 +139,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 0f2f049..d7ca12b 100644 --- a/godot.nimble +++ b/godot.nimble @@ -1,4 +1,4 @@ -version = "0.6.3" +version = "0.8.2" 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..2d816da --- /dev/null +++ b/godot/core/aabb.nim @@ -0,0 +1,79 @@ +# Copyright (c) 2018 Xored Software, Inc. + +import hashes + +import vector3 +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 hash*(self: AABB): Hash {.inline.} = + !$(self.position.hash() !& self.size.hash()) + +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).toAABB() + +proc intersection*(self, other: AABB): AABB {.inline.} = + getGDNativeAPI().aabbIntersection(self, other).toAABB() + +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).toVector3() + +proc getLongestAxis*(self: AABB): Vector3 {.inline.} = + getGDNativeAPI().aabbGetLongestAxis(self).toVector3() + +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).toVector3() + +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).toAABB() + +proc grow*(self: AABB; by: float32): AABB {.inline.} = + getGDNativeAPI().aabbGrow(self, by).toAABB() + +proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} = + getGDNativeAPI().aabbGetEndpoint(self, idx).toVector3() + +proc `==`*(a, b: AABB): bool {.inline.} = + getGDNativeAPI().aabbOperatorEqual(a, b) diff --git a/godot/core/arrays.nim b/godot/core/arrays.nim index 414ac99..fcbafb2 100644 --- a/godot/core/arrays.nim +++ b/godot/core/arrays.nim @@ -1,7 +1,7 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. import hashes -import internal.godotinternaltypes, internal.godotarrays +import internal/godotinternaltypes, internal/godotarrays type Array* = ref object @@ -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/basis.nim b/godot/core/basis.nim index 6f7e9d9..704f666 100644 --- a/godot/core/basis.nim +++ b/godot/core/basis.nim @@ -1,9 +1,12 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. + +import math, hashes -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 @@ -199,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] @@ -449,3 +455,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/colors.nim b/godot/core/colors.nim index dedb1a2..8e01b7a 100644 --- a/godot/core/colors.nim +++ b/godot/core/colors.nim @@ -1,4 +1,6 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. + +import hashes import godotcoretypes, gdnativeapi @@ -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] @@ -59,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/dictionaries.nim b/godot/core/dictionaries.nim index 5445d27..3aea17a 100644 --- a/godot/core/dictionaries.nim +++ b/godot/core/dictionaries.nim @@ -1,8 +1,8 @@ -# Copyright 2017 Xored Software, Inc. +# 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 @@ -30,9 +30,12 @@ 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() +proc hash*(self: Dictionary): Hash {.inline.} = + hash(self.godotDictionary.godotHash()) + import variants, arrays proc newVariant*(dict: Dictionary): Variant {.inline.} = @@ -40,7 +43,7 @@ proc newVariant*(dict: Dictionary): Variant {.inline.} = initGodotVariant(result.godotVariant[], dict.godotDictionary) proc asDictionary*(self: Variant): Dictionary {.inline.} = - newDictionary(self.godotVariant[].asGodotDictionary) + newDictionary(self.godotVariant[].asGodotDictionary()) proc contains*(self: Dictionary; key: Variant): bool {.inline.}= self.godotDictionary.contains(key.godotVariant[]) @@ -48,12 +51,9 @@ 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.} = - hash(self.godotDictionary.godotHash()) - proc keys*(self: Dictionary): Array {.inline.} = newArray(self.godotDictionary.keys()) @@ -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/godotbase.nim b/godot/core/godotbase.nim index 0f410b8..7b5b804 100644 --- a/godot/core/godotbase.nim +++ b/godot/core/godotbase.nim @@ -1,30 +1,64 @@ -# Copyright (c) 2017 Xored Software, Inc. +# 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 + +when (NimMajor, NimMinor, NimPatch) < (0, 20, 4): + # Newer Nim has these procs in system module + + 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 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 instInfo = instantiationInfo() + godotPrintError(cstring($error), cstring"", cstring(instInfo.filename), instInfo.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/godotcoretypes.nim b/godot/core/godotcoretypes.nim index 8b92407..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 @@ -29,7 +29,7 @@ type z*: float32 w*: float32 - Rect3* {.byref.} = object + AABB* {.byref.} = object position*: Vector3 size*: Vector3 diff --git a/godot/core/nodepaths.nim b/godot/core/nodepaths.nim index 62e30f8..bf690d7 100644 --- a/godot/core/nodepaths.nim +++ b/godot/core/nodepaths.nim @@ -1,7 +1,9 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. -import internal.godotinternaltypes, internal.godotnodepaths, - internal.godotstrings +import hashes + +import internal/godotinternaltypes, internal/godotnodepaths, + internal/godotstrings type NodePath* = ref object @@ -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() @@ -51,8 +56,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/core/planes.nim b/godot/core/planes.nim index 99dd652..2d15c79 100644 --- a/godot/core/planes.nim +++ b/godot/core/planes.nim @@ -1,8 +1,10 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. + +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.} = @@ -20,14 +22,17 @@ 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) + 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) @@ -40,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.} = @@ -55,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/poolarrays.nim b/godot/core/poolarrays.nim index dd3f544..29fda96 100644 --- a/godot/core/poolarrays.nim +++ b/godot/core/poolarrays.nim @@ -1,8 +1,11 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. + +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, initProcName) = @@ -26,48 +29,11 @@ template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName, new(result, poolArrayFinalizer) result.fieldName = arr -template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName; - noData = false) = - - proc newProcName*(arr: Array): T {.inline.} = - new(result, poolArrayFinalizer) - initProcName(result.fieldName, arr.godotArray[]) - - proc add*(self: var T; arr: T) {.inline.} = - self.fieldName.add(arr.fieldName) - - proc delete*(self: var T; idx: int) {.inline.} = - self.fieldName.delete(idx.cint) - - proc reverse*(self: var T) {.inline.} = - self.fieldName.reverse() - - proc setLen*(self: var 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.} = - self.fieldName.add(data) - - proc insert*(self: var T; idx: int; data: DataT): Error {.inline.} = - self.fieldName.insert(idx.cint, data) - - proc `[]=`*(self: var T; idx: int; data: DataT) {.inline.} = - self.fieldName[idx.cint] = data - - proc `[]`*(self: T; idx: int): DataT {.inline.} = - self.fieldName[idx.cint] - - iterator items*(arr: T): DataT = - for i in 0..= 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) + + proc insert*(self: T; idx: int; data: DataT): Error {.inline.} = + self.fieldName.insert(idx.cint, data) + + proc `[]=`*(self: T; idx: int; data: DataT) {.inline.} = + self.fieldName[idx.cint] = data + + proc `[]`*(self: T; idx: int): DataT {.inline.} = + self.fieldName[idx.cint] + + iterator items*(arr: T): DataT = + for item in arr.fieldName.items: + yield item + + iterator pairs*(arr: T): tuple[key: int, val: DataT] = + for pair in arr.fieldName.pairs: + yield (pair[0].int, pair[1]) + + iterator mitems*(arr: T): var DataT = + for item in arr.fieldName.mitems: + yield item + + iterator mpairs*(arr: T): tuple[key: int, val: var DataT] = + for pair in arr.fieldName.mpairs: + yield (pair[0].int, pair[1]) + definePoolArray(PoolByteArray, GodotPoolByteArray, uint8, godotPoolByteArray, newPoolByteArray, initGodotPoolByteArray) definePoolArray(PoolIntArray, GodotPoolIntArray, cint, godotPoolIntArray, newPoolIntArray, initGodotPoolIntArray) -definePoolArray(PoolRealArray, GodotPoolRealArray, float64, +definePoolArray(PoolRealArray, GodotPoolRealArray, float32, godotPoolRealArray, newPoolRealArray, initGodotPoolRealArray) definePoolArray(PoolVector2Array, GodotPoolVector2Array, Vector2, @@ -115,17 +138,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() diff --git a/godot/core/quats.nim b/godot/core/quats.nim index ea8cad4..db88b10 100644 --- a/godot/core/quats.nim +++ b/godot/core/quats.nim @@ -1,6 +1,8 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. -import internal.godotinternaltypes, internal.godotstrings +import hashes + +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi proc initQuat*(x, y, z, w: float32): Quat {.inline.} = @@ -17,6 +19,9 @@ proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} = proc `$`*(self: Quat): string {.inline.} = $getGDNativeAPI().quatAsString(self) +proc hash*(self: Quat): Hash {.inline.} = + !$(self.x.hash() !& self.y.hash() !& self.z.hash() !& self.w.hash()) + proc length*(self: Quat): float32 {.inline.} = getGDNativeAPI().quatLength(self) @@ -24,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 @@ -76,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/rect2.nim b/godot/core/rect2.nim index ad813a9..19b8cbf 100644 --- a/godot/core/rect2.nim +++ b/godot/core/rect2.nim @@ -1,44 +1,153 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. + +import hashes import vector2 -import internal.godotinternaltypes, internal.godotstrings +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.} = +proc `$`*(self: Rect2): string {.inline, noinit.} = $getGDNativeAPI().rect2AsString(self) -proc area*(self: Rect2): float32 {.inline.} = - getGDNativeAPI().rect2GetArea(self) +proc hash*(self: Rect2): Hash {.inline, noinit.} = + !$(self.position.hash() !& self.size.hash()) -proc intersects*(a, b: Rect2): bool {.inline.} = - getGDNativeAPI().rect2Intersects(a, b) +proc area*(self: Rect2): float32 {.inline, noinit.} = + self.size.x * self.size.y -proc encloses*(a, b: Rect2): bool {.inline.} = - getGDNativeAPI().rect2Encloses(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 hasNoArea*(self: Rect2): bool {.inline.} = - getGDNativeAPI().rect2HasNoArea(self) +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 clip*(self, b: Rect2): Rect2 {.inline.} = - getGDNativeAPI().rect2Clip(self, b) + if inside: + result = 0'f32 -proc merge*(self, b: Rect2): Rect2 {.inline.} = - getGDNativeAPI().rect2Merge(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 contains*(self: Rect2; point: Vector2): bool {.inline.} = - getGDNativeAPI().rect2HasPoint(self, point) +proc hasNoArea*(self: Rect2): bool {.inline, noinit.} = + self.size.x <= 0 or self.size.y <= 0 -proc grow*(self: Rect2; by: float32): Rect2 {.inline.} = - getGDNativeAPI().rect2Grow(self, by) +proc clip*(self, b: Rect2): Rect2 {.inline, noinit.} = + if not self.intersects(b): + return initRect2() -proc expand*(self: Rect2; to: Vector2): Rect2 {.inline.} = - getGDNativeAPI().rect2Expand(self, to) + result = self -proc `==`*(a, b: Rect2): bool {.inline.} = - getGDNativeAPI().rect2OperatorEqual(a, b) + result.position.x = max(b.position.x, self.position.x) + result.position.y = max(b.position.y, self.position.y) + + 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/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/rids.nim b/godot/core/rids.nim index a113f60..a64137d 100644 --- a/godot/core/rids.nim +++ b/godot/core/rids.nim @@ -1,6 +1,8 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. -import godotcoretypes, internal.godotinternaltypes, gdnativeapi +import hashes + +import godotcoretypes, internal/godotinternaltypes, gdnativeapi proc initRID*(): RID {.inline.} = getGDNativeAPI().ridNew(result) @@ -14,6 +16,9 @@ proc id*(self: RID): uint32 {.inline.} = proc `$`*(self: RID): string {.inline.} = $self.id +proc hash*(self: RID): Hash {.inline.} = + self.id.hash() + proc `==`*(a, b: RID): bool {.inline.} = getGDNativeAPI().ridOperatorEqual(a, b) diff --git a/godot/core/transform2d.nim b/godot/core/transform2d.nim index 922b24b..a8db09e 100644 --- a/godot/core/transform2d.nim +++ b/godot/core/transform2d.nim @@ -1,6 +1,8 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. -import internal.godotinternaltypes, internal.godotstrings +import hashes, vector2 + +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi proc initTransform2D*(): Transform2D {.inline.} = @@ -15,60 +17,63 @@ proc initTransform2D*(xAxis, yAxis, origin: Vector2): Transform2D {.inline.} = proc `$`*(self: Transform2D): string {.inline.} = $getGDNativeAPI().transform2DAsString(self) +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 f70a1f8..501f743 100644 --- a/godot/core/transforms.nim +++ b/godot/core/transforms.nim @@ -1,8 +1,10 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. -import internal.godotinternaltypes, internal.godotstrings +import hashes + +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi -import basis +import basis, vector3 proc initTransform*(): Transform {.inline.} = result.basis = initBasis() @@ -21,51 +23,54 @@ proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} = proc `$`*(self: Transform): string {.inline.} = $getGDNativeAPI().transformAsString(self) +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 xformRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} = - getGDNativeAPI().transformXformRect3(self, rect) +proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} = + getGDNativeAPI().transformXformAABB(self, rect).toAABB() -proc xformInvRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} = - getGDNativeAPI().transformXformInvRect3(self, rect) +proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} = + 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/core/variants.nim b/godot/core/variants.nim index 2dcc8d8..fcb2b04 100644 --- a/godot/core/variants.nim +++ b/godot/core/variants.nim @@ -1,8 +1,9 @@ -import tables +import tables, hashes import godotcoretypes -import internal.godotinternaltypes, internal.godotvariants, - internal.godotstrings +import internal/godotinternaltypes, internal/godotvariants, + internal/godotstrings, internal/godotdictionaries, + internal/godotarrays type Variant* = ref object @@ -72,15 +73,16 @@ 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() + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + if s.isNil: + initGodotVariant(result.godotVariant) + return + var godotStr = s.toGodotString() + initGodotVariant(result.godotVariant, godotStr) + 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 +110,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) @@ -140,11 +142,7 @@ proc newVariant*(obj: ptr GodotObject): Variant {.inline.} = new(result, variantFinalizer) initGodotVariant(result.godotVariant, obj) -import arrays, poolarrays - -proc newVariant*(arr: Array): Variant {.inline.} = - new(result, variantFinalizer) - initGodotVariant(result.godotVariant, arr.godotArray[]) +import poolarrays proc newVariant*(pba: PoolByteArray): Variant {.inline.} = new(result, variantFinalizer) @@ -177,81 +175,119 @@ proc newVariant*(pca: PoolColorArray): Variant {.inline.} = proc asBool*(self: Variant): bool {.inline.} = self.godotVariant.asBool() -proc asUInt*(self: Variant): uint64 = +proc asUInt*(self: Variant): uint64 {.inline.} = self.godotVariant.asUInt() -proc asInt*(self: Variant): int64 = +proc asInt*(self: Variant): int64 {.inline.} = self.godotVariant.asInt() -proc asReal*(self: Variant): cdouble = +proc asReal*(self: Variant): cdouble {.inline.} = self.godotVariant.asReal() -proc asString*(self: Variant): string = +proc asString*(self: Variant): string {.inline.} = $self -proc asVector2*(self: Variant): Vector2 = +proc asVector2*(self: Variant): Vector2 {.inline.} = self.godotVariant.asVector2() -proc asRect2*(self: Variant): Rect2 = +proc asRect2*(self: Variant): Rect2 {.inline.} = self.godotVariant.asRect2() -proc asVector3*(self: Variant): Vector3 = +proc asVector3*(self: Variant): Vector3 {.inline.} = self.godotVariant.asVector3() -proc asTransform2D*(self: Variant): Transform2D = +proc asTransform2D*(self: Variant): Transform2D {.inline.} = self.godotVariant.asTransform2D() -proc asPlane*(self: Variant): Plane = +proc asPlane*(self: Variant): Plane {.inline.} = self.godotVariant.asPlane() -proc asQuat*(self: Variant): Quat = +proc asQuat*(self: Variant): Quat {.inline.} = self.godotVariant.asQuat() -proc asRect3*(self: Variant): Rect3 = - self.godotVariant.asRect3() +proc asAABB*(self: Variant): AABB {.inline.} = + self.godotVariant.asAABB() -proc asBasis*(self: Variant): Basis = +proc asBasis*(self: Variant): Basis {.inline.} = self.godotVariant.asBasis() -proc asTransform*(self: Variant): Transform = +proc asTransform*(self: Variant): Transform {.inline.} = self.godotVariant.asTransform() -proc asColor*(self: Variant): Color = +proc asColor*(self: Variant): Color {.inline.} = self.godotVariant.asColor() -proc asNodePath*(self: Variant): NodePath = +proc asNodePath*(self: Variant): NodePath {.inline.} = result = newNodePath(self.godotVariant.asNodePath()) -proc asRID*(self: Variant): RID = +proc asRID*(self: Variant): RID {.inline.} = self.godotVariant.asRID() -proc asGodotObject*(self: Variant): ptr GodotObject = +proc asGodotObject*(self: Variant): ptr GodotObject {.inline.} = self.godotVariant.asGodotObject() -proc asArray*(self: Variant): Array = - newArray(self.godotVariant.asGodotArray()) - -proc asPoolByteArray*(self: Variant): PoolByteArray = +proc asPoolByteArray*(self: Variant): PoolByteArray {.inline.} = newPoolByteArray(self.godotVariant.asGodotPoolByteArray()) -proc asPoolIntArray*(self: Variant): PoolIntArray = +proc asPoolIntArray*(self: Variant): PoolIntArray {.inline.} = newPoolIntArray(self.godotVariant.asGodotPoolIntArray()) -proc asPoolRealArray*(self: Variant): PoolRealArray = +proc asPoolRealArray*(self: Variant): PoolRealArray {.inline.} = newPoolRealArray(self.godotVariant.asGodotPoolRealArray()) -proc asPoolStringArray*(self: Variant): PoolStringArray = +proc asPoolStringArray*(self: Variant): PoolStringArray {.inline.} = newPoolStringArray(self.godotVariant.asGodotPoolStringArray()) -proc asPoolVector2Array*(self: Variant): PoolVector2Array = +proc asPoolVector2Array*(self: Variant): PoolVector2Array {.inline.} = newPoolVector2Array(self.godotVariant.asGodotPoolVector2Array()) -proc asPoolVector3Array*(self: Variant): PoolVector3Array = +proc asPoolVector3Array*(self: Variant): PoolVector3Array {.inline.} = newPoolVector3Array(self.godotVariant.asGodotPoolVector3Array()) -proc asPoolColorArray*(self: Variant): PoolColorArray = +proc asPoolColorArray*(self: Variant): PoolColorArray {.inline.} = newPoolColorArray(self.godotVariant.asGodotPoolColorArray()) +proc hash*(self: Variant): Hash = + proc objectHash(obj: ptr GodotObject): Hash = + if not obj.isNil: cast[int](obj).hash() else: 0.hash() + result = case self.getType(): + of VariantType.Nil: Hash(0) + of VariantType.Bool: self.asBool().hash() + of VariantType.Int: self.asInt().hash() + of VariantType.Real: self.asReal().hash() + of VariantType.String: self.asString().hash() + of VariantType.Vector2: self.asVector2().hash() + of VariantType.Rect2: self.asRect2().hash() + of VariantType.Vector3: self.asVector3().hash() + of VariantType.Transform2D: self.asTransform2D().hash() + of VariantType.Plane: self.asPlane().hash() + of VariantType.Quat: self.asQuat().hash() + of VariantType.AABB: self.asAABB().hash() + of VariantType.Basis: self.asBasis().hash() + of VariantType.Transform: self.asTransform().hash() + of VariantType.Color: self.asColor().hash() + of VariantType.NodePath: self.asNodePath().hash() + of VariantType.RID: self.asRID().hash() + of VariantType.Object: self.asGodotObject().objectHash() + of VariantType.Dictionary: hash(self.godotVariant.asGodotDictionary().godotHash()) + of VariantType.Array: hash(self.godotVariant.asGodotArray().godotHash()) + of VariantType.PoolByteArray: self.asPoolByteArray().hash() + of VariantType.PoolIntArray: self.asPoolIntArray().hash() + of VariantType.PoolRealArray: self.asPoolRealArray().hash() + of VariantType.PoolStringArray: self.asPoolStringArray().hash() + of VariantType.PoolVector2Array: self.asPoolVector2Array().hash() + of VariantType.PoolVector3Array: self.asPoolVector3Array().hash() + of VariantType.PoolColorArray: self.asPoolColorArray().hash() + +import arrays + +proc newVariant*(arr: Array): Variant {.inline.} = + new(result, variantFinalizer) + initGodotVariant(result.godotVariant, arr.godotArray[]) + +proc asArray*(self: Variant): Array {.inline.} = + newArray(self.godotVariant.asGodotArray()) + proc hasMethod*(self: Variant; meth: string): bool = var s = meth.toGodotString() result = self.godotVariant.hasMethod(s) diff --git a/godot/core/vector2.nim b/godot/core/vector2.nim index 9eca64d..390f1f6 100644 --- a/godot/core/vector2.nim +++ b/godot/core/vector2.nim @@ -1,122 +1,214 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. -import internal.godotinternaltypes, internal.godotstrings +import math, godotbase, hashes + +import internal/godotinternaltypes, internal/godotstrings import godotcoretypes, gdnativeapi -proc vec2*(x, y: float32): Vector2 {.inline.} = +const EPSILON = 0.00001'f32 + +{.push stackTrace: off.} + +proc vec2*(): Vector2 {.inline, noinit.} = + Vector2() + +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 hash*(self: Vector2): Hash {.inline, noinit.} = + !$(self.x.hash() !& self.y.hash()) -proc length*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2Length(self) +proc `+`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x + other.x, y: self.y + other.y) -proc angle*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2Angle(self) +proc `+=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x += other.x + self.y += other.y -proc lengthSquared*(self: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2LengthSquared(self) +proc `-`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x - other.x, y: self.y - other.y) -proc isNormalized*(self: Vector2): bool {.inline.} = - getGDNativeAPI().vector2IsNormalized(self) +proc `-=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x -= other.x + self.y -= other.y -proc distanceTo*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2DistanceTo(self, to) +proc `*`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x * other.x, y: self.y * other.y) -proc distanceSquaredTo*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2DistanceSquaredTo(self, to) +proc `*=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x *= other.x + self.y *= other.y -proc angleTo*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2AngleTo(self, to) +proc `*`*(self: Vector2, scalar: float32): Vector2 {.inline, noinit.} = + Vector2(x: self.x * scalar, y: self.y * scalar) -proc angleToPoint*(self, to: Vector2): float32 {.inline.} = - getGDNativeAPI().vector2AngleToPoint(self, to) +proc `*`*(scalar: float32, v: Vector2): Vector2 {.inline, noinit.} = + v * scalar -proc lerp*(self, b: Vector2; t: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2LinearInterpolate(self, b, t) +proc `*=`*(self: var Vector2, scalar: float32) {.inline, noinit.} = + self.x *= scalar + self.y *= scalar -proc cubicInterpolate*(self, b, preA, postB: Vector2; - t: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2CubicInterpolate(self, b, preA, postB, t) +proc `/`*(self, other: Vector2): Vector2 {.inline, noinit.} = + Vector2(x: self.x / other.x, y: self.y / other.y) -proc rotated*(self: Vector2; phi: float32): Vector2 {.inline.} = - getGDNativeAPI().vector2Rotated(self, phi) +proc `/=`*(self: var Vector2, other: Vector2) {.inline, noinit.} = + self.x /= other.x + self.y /= other.y -proc tangent*(self: Vector2): Vector2 {.inline.} = - getGDNativeAPI().vector2Tangent(self) +proc `/`*(self: Vector2; scalar: float32): Vector2 {.inline, noinit.} = + Vector2(x: self.x / scalar, y: self.y / scalar) -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: 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 + +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 ded30ce..ed2903a 100644 --- a/godot/core/vector3.nim +++ b/godot/core/vector3.nim @@ -1,8 +1,12 @@ -# Copyright (c) 2017 Xored Software, Inc. +# Copyright (c) 2018 Xored Software, Inc. -import math +import math, hashes import godotbase, godotcoretypes +const EPSILON = 0.00001'f32 + +{.push stackTrace: off.} + proc vec3*(): Vector3 {.inline.} = Vector3() @@ -19,6 +23,9 @@ proc `$`*(self: Vector3): string {.inline.} = result.add($self.z) result.add(')') +proc hash*(self: Vector3): Hash {.inline, noinit.} = + !$(self.x.hash() !& self.y.hash() !& self.z.hash()) + proc `+`*(a, b: Vector3): Vector3 {.inline.} = result.x = a.x + b.x result.y = a.y + b.y @@ -233,3 +240,15 @@ 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) + +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 diff --git a/godot/gdnativeapi.nim b/godot/gdnativeapi.nim index 8af25da..bb05425 100644 --- a/godot/gdnativeapi.nim +++ b/godot/gdnativeapi.nim @@ -1,1451 +1,3617 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. -import internal.godotinternaltypes, core.godotcoretypes +import internal/godotinternaltypes, core/godotcoretypes, macros -type GDNativeAPI* = object - next: pointer - version: cstring +type + ColorData* {.byref.} = object + data: array[16, uint8] - # 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.} + Vector3Data* {.byref.} = object + data: array[12, uint8] - # 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 + 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, + GDNativeExtPluginScript, + GDNativeExtNativeARVR + + 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): ColorData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorContrasted: proc (self: Color): ColorData {.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): ColorData {.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): ColorData + {.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): Vector2Data + {.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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2CubicInterpolate: proc (self, b, preA, postB: Vector2, + t: float32): Vector2Data {.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): Vector2Data {.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): Vector2Data {.noconv, raises: [], gcsafe, tags: [], locks: 0.} - poolRealArrayNewCopy*: proc (dest: var GodotPoolRealArray, - src: GodotPoolRealArray) + vector2Floor: proc (self: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Bounce: proc (self, n: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Reflect: proc (self, n: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Abs: proc (self: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Clamped: proc (self: Vector2, length: float32): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorAdd: proc (self, other: Vector2): Vector2Data {.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): Vector2Data {.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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyScalar: proc (self: Vector2, scalar: float32): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideVector: proc (self, other: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + 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): Vector2Data + {.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): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatIsNormalized: proc (self: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerp: proc (self, other: Quat, t: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerpni: proc (self, other: Quat, t: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatCubicSlerp: proc (self, other, preA, postB: Quat, t: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorMultiply: proc (self: Quat, b: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorAdd: proc (self, other: Quat): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorSubtract: proc (self, other: Quat): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): QuatData + {.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: proc (self: GodotPoolByteArray): ptr GodotPoolByteArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWrite: proc (self: var GodotPoolByteArray): ptr GodotPoolByteArrayWriteAccess + {.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.} + poolIntArrayRead: proc (self: GodotPoolIntArray): ptr GodotPoolIntArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWrite: proc (self: var GodotPoolIntArray): ptr GodotPoolIntArrayWriteAccess + {.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.} + poolRealArrayRead: proc (self: GodotPoolRealArray): ptr GodotPoolRealArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWrite: proc (self: var GodotPoolRealArray): ptr GodotPoolRealArrayWriteAccess + {.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.} + poolStringArrayRead: proc (self: GodotPoolStringArray): ptr GodotPoolStringArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWrite: proc (self: var GodotPoolStringArray): ptr GodotPoolStringArrayWriteAccess + {.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.} + poolVector2ArrayRead: proc (self: GodotPoolVector2Array): ptr GodotPoolVector2ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWrite: proc (self: var GodotPoolVector2Array): ptr GodotPoolVector2ArrayWriteAccess + {.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): Vector2Data + {.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: proc (self: GodotPoolVector3Array): ptr GodotPoolVector3ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWrite: proc (self: var GodotPoolVector3Array): ptr GodotPoolVector3ArrayWriteAccess + {.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): Vector3Data + {.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: proc (self: GodotPoolColorArray): ptr GodotPoolColorArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWrite: proc (self: var GodotPoolColorArray): ptr GodotPoolColorArrayWriteAccess + {.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): ColorData + {.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/Write Access API + + poolByteArrayReadAccessCopy: proc (self: ptr GodotPoolByteArrayReadAccess): ptr GodotPoolByteArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayReadAccessPtr: proc (self: ptr GodotPoolByteArrayReadAccess): ptr byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolByteArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayReadAccessDestroy: proc (self: ptr GodotPoolByteArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolIntArrayReadAccessCopy: proc (self: ptr GodotPoolIntArrayReadAccess): ptr GodotPoolIntArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayReadAccessPtr: proc (self: ptr GodotPoolIntArrayReadAccess): ptr cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolIntArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayReadAccessDestroy: proc (self: ptr GodotPoolIntArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolRealArrayReadAccessCopy: proc (self: ptr GodotPoolRealArrayReadAccess): ptr GodotPoolRealArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayReadAccessPtr: proc (self: ptr GodotPoolRealArrayReadAccess): ptr float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolRealArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayReadAccessDestroy: proc (self: ptr GodotPoolRealArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolStringArrayReadAccessCopy: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotPoolStringArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayReadAccessPtr: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolStringArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayReadAccessDestroy: proc (self: ptr GodotPoolStringArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector2ArrayReadAccessCopy: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr GodotPoolVector2ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayReadAccessPtr: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolVector2ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayReadAccessDestroy: proc (self: ptr GodotPoolVector2ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector3ArrayReadAccessCopy: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr GodotPoolVector3ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayReadAccessPtr: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolVector3ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayReadAccessDestroy: proc (self: ptr GodotPoolVector3ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolColorArrayReadAccessCopy: proc (self: ptr GodotPoolColorArrayReadAccess): ptr GodotPoolColorArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayReadAccessPtr: proc (self: ptr GodotPoolColorArrayReadAccess): ptr Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolColorArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayReadAccessDestroy: proc (self: ptr GodotPoolColorArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolByteArrayWriteAccessCopy: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr GodotPoolByteArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWriteAccessPtr: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolByteArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWriteAccessDestroy: proc (self: ptr GodotPoolByteArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolIntArrayWriteAccessCopy: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr GodotPoolIntArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWriteAccessPtr: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolIntArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWriteAccessDestroy: proc (self: ptr GodotPoolIntArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolRealArrayWriteAccessCopy: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr GodotPoolRealArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWriteAccessPtr: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolRealArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWriteAccessDestroy: proc (self: ptr GodotPoolRealArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolStringArrayWriteAccessCopy: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotPoolStringArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWriteAccessPtr: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolStringArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWriteAccessDestroy: proc (self: ptr GodotPoolStringArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector2ArrayWriteAccessCopy: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr GodotPoolVector2ArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWriteAccessPtr: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolVector2ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWriteAccessDestroy: proc (self: ptr GodotPoolVector2ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector3ArrayWriteAccessCopy: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr GodotPoolVector3ArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWriteAccessPtr: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolVector3ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWriteAccessDestroy: proc (self: ptr GodotPoolVector3ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolColorArrayWriteAccessCopy: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr GodotPoolColorArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWriteAccessPtr: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolColorArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWriteAccessDestroy: proc (self: ptr GodotPoolColorArrayWriteAccess) + {.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.} + 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.} + 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.} + + # 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.} + 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 + {.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): PlaneData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeCenter: proc (self: Plane): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetAnyPoint: proc (self: Plane): Vector3Data + {.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): Vector3Data + {.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): 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): Vector3Data + {.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): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetSize: proc (self: Rect2): Vector2Data + {.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.} + + # AABB API + aabbNew: proc (dest: var AABB, pos, size: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbSetSize: proc (self: var AABB, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbAsString: proc (self: AABB): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetArea: proc (self: AABB): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbHasNoArea: proc (self: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbHasNoSurface: proc (self: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbIntersects: proc (self, other: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbEncloses: proc (self, other: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbMerge: proc (self, other: AABB): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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.} + aabbIntersectsSegment: proc (self: AABB, vFrom, vTo: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbHasPoint: proc (self: AABB, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetSupport: proc (self: AABB, dir: Vector3): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetLongestAxis: proc (self: AABB): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetLongestAxisIndex: proc (self: AABB): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbGetLongestAxisSize: proc (self: AABB): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbGetShortestAxis: proc (self: AABB): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetShortestAxisIndex: proc (self: AABB): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbGetShortestAxisSize: proc (self: AABB): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbExpand: proc (self: AABB, toPoint: Vector3): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGrow: proc (self: AABB, by: float32): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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.} + + # 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): BasisData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetBasis: proc (self: var Transform, basis: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAffineInverse: proc (self: Transform): TransformData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOrthonormalized: proc (self: Transform): TransformData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformRotated: proc (self: Transform, axis: Vector3, + phi: float32): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformScaled: proc (self: Transform, scale: Vector3): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformTranslated: proc (self: Transform, offset: Vector3): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformLookingAt: proc (self: Transform, target, up: Vector3): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformPlane: proc (self: Transform, plane: Plane): PlaneData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvPlane: proc (self: Transform, plane: Plane): PlaneData + {.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): TransformData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformVector3: proc (self: Transform, v: Vector3): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformInvVector3: proc (self: Transform, v: Vector3): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformAABB: proc (self: Transform, v: AABB): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvAABB: proc (self: Transform, v: AABB): AABBData + {.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): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DGetScale: proc (self: Transform2D): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DOrthonormalized: proc (self: Transform2D): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DRotated: proc (self: Transform2D, phi: float32): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DScaled: proc (self: Transform2D, scale: Vector2): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DTranslated: proc (self: Transform2D, offset: Vector2): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformVector2: proc (self: Transform2D, v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvVector2: proc (self: Transform2D, v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformVector2: proc (self: Transform2D, v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformInvVector2: proc (self: Transform2D, + v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DInterpolateWith: proc (self, other: 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): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DNewIdentity: proc (dest: var Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformRect2: proc (self: Transform2D, v: Rect2): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvRect2: proc (self: Transform2D, v: Rect2): Rect2Data + {.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.} + 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.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect2: proc (self: GodotVariant): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector3: proc (self: GodotVariant): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform2D: proc (self: GodotVariant): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPlane: proc (self: GodotVariant): PlaneData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsQuat: proc (self: GodotVariant): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsAABB: proc (self: GodotVariant): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsBasis: proc (self: GodotVariant): BasisData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform: proc (self: GodotVariant): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsColor: proc (self: GodotVariant): ColorData + {.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 + 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.} + stringNewWithWideString: pointer + stringOperatorIndex: pointer + stringOperatorIndexConst: 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 + {.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.} + stringCasecmpTo: pointer + stringNocasecmpTo: pointer + stringNaturalnocasecmpTo: pointer + 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: proc (self: GodotString): GodotCharString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + stringParseUtf8: pointer + stringParseUtf8WithLen: 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 + 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.} + getGlobalConstants: pointer + 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 + {.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): ColorData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorContrasted*: proc (self: Color): ColorData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + colorLinearInterpolate*: proc (self, other: Color, t: float32): ColorData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + 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.} + 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): Vector2Data + {.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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2CubicInterpolate*: proc (self, b, preA, postB: Vector2, + t: float32): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2Rotated*: proc (self: Vector2, phi: float32): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Tangent*: proc (self: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Floor*: proc (self: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Bounce*: proc (self, n: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Reflect*: proc (self, n: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Abs*: proc (self: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2Clamped*: proc (self: Vector2, length: float32): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorAdd*: proc (self, other: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + vector2OperatorSubtract*: proc (self, other: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyVector*: proc (self, other: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorMultiplyScalar*: proc (self: Vector2, scalar: float32): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + vector2OperatorDivideVector*: proc (self, other: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + 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): Vector2Data + {.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): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatIsNormalized*: proc (self: Quat): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerp*: proc (self, other: Quat, t: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatSlerpni*: proc (self, other: Quat, t: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatCubicSlerp*: proc (self, other, preA, postB: Quat, t: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorMultiply*: proc (self: Quat, b: float32): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorAdd*: proc (self, other: Quat): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + quatOperatorSubtract*: proc (self, other: Quat): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): QuatData + {.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.} + poolByteArrayRead*: proc (self: GodotPoolByteArray): ptr GodotPoolByteArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWrite*: proc (self: var GodotPoolByteArray): ptr GodotPoolByteArrayWriteAccess + {.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.} + poolIntArrayRead*: proc (self: GodotPoolIntArray): ptr GodotPoolIntArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWrite*: proc (self: var GodotPoolIntArray): ptr GodotPoolIntArrayWriteAccess + {.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.} + poolRealArrayRead*: proc (self: GodotPoolRealArray): ptr GodotPoolRealArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWrite*: proc (self: var GodotPoolRealArray): ptr GodotPoolRealArrayWriteAccess + {.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.} + poolStringArrayRead*: proc (self: GodotPoolStringArray): ptr GodotPoolStringArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWrite*: proc (self: var GodotPoolStringArray): ptr GodotPoolStringArrayWriteAccess + {.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.} + poolVector2ArrayRead*: proc (self: GodotPoolVector2Array): ptr GodotPoolVector2ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWrite*: proc (self: var GodotPoolVector2Array): ptr GodotPoolVector2ArrayWriteAccess + {.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): Vector2Data + {.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*: proc (self: GodotPoolVector3Array): ptr GodotPoolVector3ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWrite*: proc (self: var GodotPoolVector3Array): ptr GodotPoolVector3ArrayWriteAccess + {.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): Vector3Data + {.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.} + poolColorArrayRead*: proc (self: GodotPoolColorArray): ptr GodotPoolColorArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWrite*: proc (self: var GodotPoolColorArray): ptr GodotPoolColorArrayWriteAccess + {.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): ColorData + {.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/Write Access API + poolByteArrayReadAccessCopy*: proc (self: ptr GodotPoolByteArrayReadAccess): ptr GodotPoolByteArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayReadAccessPtr*: proc (self: ptr GodotPoolByteArrayReadAccess): ptr byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolByteArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayReadAccessDestroy*: proc (self: ptr GodotPoolByteArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} -var gdNativeAPI: ptr GDNativeAPI + poolIntArrayReadAccessCopy*: proc (self: ptr GodotPoolIntArrayReadAccess): ptr GodotPoolIntArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayReadAccessPtr*: proc (self: ptr GodotPoolIntArrayReadAccess): ptr cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolIntArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayReadAccessDestroy*: proc (self: ptr GodotPoolIntArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolRealArrayReadAccessCopy*: proc (self: ptr GodotPoolRealArrayReadAccess): ptr GodotPoolRealArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayReadAccessPtr*: proc (self: ptr GodotPoolRealArrayReadAccess): ptr float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolRealArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayReadAccessDestroy*: proc (self: ptr GodotPoolRealArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolStringArrayReadAccessCopy*: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotPoolStringArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayReadAccessPtr*: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolStringArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayReadAccessDestroy*: proc (self: ptr GodotPoolStringArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector2ArrayReadAccessCopy*: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr GodotPoolVector2ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayReadAccessPtr*: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector2ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayReadAccessDestroy*: proc (self: ptr GodotPoolVector2ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector3ArrayReadAccessCopy*: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr GodotPoolVector3ArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayReadAccessPtr*: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector3ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayReadAccessDestroy*: proc (self: ptr GodotPoolVector3ArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolColorArrayReadAccessCopy*: proc (self: ptr GodotPoolColorArrayReadAccess): ptr GodotPoolColorArrayReadAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayReadAccessPtr*: proc (self: ptr GodotPoolColorArrayReadAccess): ptr Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolColorArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayReadAccessDestroy*: proc (self: ptr GodotPoolColorArrayReadAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolByteArrayWriteAccessCopy*: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr GodotPoolByteArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWriteAccessPtr*: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr byte + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolByteArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolByteArrayWriteAccessDestroy*: proc (self: ptr GodotPoolByteArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolIntArrayWriteAccessCopy*: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr GodotPoolIntArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWriteAccessPtr*: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr cint + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolIntArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolIntArrayWriteAccessDestroy*: proc (self: ptr GodotPoolIntArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolRealArrayWriteAccessCopy*: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr GodotPoolRealArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWriteAccessPtr*: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolRealArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolRealArrayWriteAccessDestroy*: proc (self: ptr GodotPoolRealArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolStringArrayWriteAccessCopy*: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotPoolStringArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWriteAccessPtr*: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolStringArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolStringArrayWriteAccessDestroy*: proc (self: ptr GodotPoolStringArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector2ArrayWriteAccessCopy*: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr GodotPoolVector2ArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWriteAccessPtr*: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr Vector2 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector2ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector2ArrayWriteAccessDestroy*: proc (self: ptr GodotPoolVector2ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolVector3ArrayWriteAccessCopy*: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr GodotPoolVector3ArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWriteAccessPtr*: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr Vector3 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector3ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolVector3ArrayWriteAccessDestroy*: proc (self: ptr GodotPoolVector3ArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + + poolColorArrayWriteAccessCopy*: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr GodotPoolColorArrayWriteAccess + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWriteAccessPtr*: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr Color + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolColorArrayWriteAccess) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + poolColorArrayWriteAccessDestroy*: proc (self: ptr GodotPoolColorArrayWriteAccess) + {.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.} + 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.} + + # 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.} + 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 + {.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): PlaneData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeCenter*: proc (self: Plane): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + planeGetAnyPoint*: proc (self: Plane): Vector3Data + {.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): Vector3Data + {.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): 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): Vector3Data + {.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): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + rect2GetSize*: proc (self: Rect2): Vector2Data + {.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.} + + # AABB API + aabbNew*: proc (dest: var AABB, pos, size: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbSetSize*: proc (self: var AABB, pos: Vector3) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbAsString*: proc (self: AABB): GodotString + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetArea*: proc (self: AABB): float32 + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbHasNoArea*: proc (self: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbHasNoSurface*: proc (self: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbIntersects*: proc (self, other: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbEncloses*: proc (self, other: AABB): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbMerge*: proc (self, other: AABB): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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.} + aabbIntersectsSegment*: proc (self: AABB, vFrom, vTo: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbHasPoint*: proc (self: AABB, point: Vector3): bool + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetSupport*: proc (self: AABB, dir: Vector3): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetLongestAxis*: proc (self: AABB): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetLongestAxisIndex*: proc (self: AABB): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbGetLongestAxisSize*: proc (self: AABB): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbGetShortestAxis*: proc (self: AABB): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGetShortestAxisIndex*: proc (self: AABB): cint + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbGetShortestAxisSize*: proc (self: AABB): float32 + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + aabbExpand*: proc (self: AABB, toPoint: Vector3): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + aabbGrow*: proc (self: AABB, by: float32): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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.} + + # 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): BasisData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformSetBasis*: proc (self: var Transform, basis: Basis) + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformAffineInverse*: proc (self: Transform): TransformData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformOrthonormalized*: proc (self: Transform): TransformData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformRotated*: proc (self: Transform, axis: Vector3, + phi: float32): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformScaled*: proc (self: Transform, scale: Vector3): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformTranslated*: proc (self: Transform, offset: Vector3): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformLookingAt*: proc (self: Transform, target, up: Vector3): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformPlane*: proc (self: Transform, plane: Plane): PlaneData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvPlane*: proc (self: Transform, plane: Plane): PlaneData + {.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): TransformData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformVector3*: proc (self: Transform, v: Vector3): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformInvVector3*: proc (self: Transform, v: Vector3): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transformXformAABB*: proc (self: Transform, v: AABB): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transformXformInvAABB*: proc (self: Transform, v: AABB): AABBData + {.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): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DGetScale*: proc (self: Transform2D): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DOrthonormalized*: proc (self: Transform2D): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DRotated*: proc (self: Transform2D, phi: float32): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DScaled*: proc (self: Transform2D, scale: Vector2): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + transform2DTranslated*: proc (self: Transform2D, offset: Vector2): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformVector2*: proc (self: Transform2D, v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvVector2*: proc (self: Transform2D, v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformVector2*: proc (self: Transform2D, v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DBasisXformInvVector2*: proc (self: Transform2D, + v: Vector2): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DInterpolateWith*: proc (self, other: 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): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DNewIdentity*: proc (dest: var Transform2D) + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformRect2*: proc (self: Transform2D, v: Rect2): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], + locks: 0.} + transform2DXformInvRect2*: proc (self: Transform2D, v: Rect2): Rect2Data + {.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.} + 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.} + 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): Vector2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsRect2*: proc (self: GodotVariant): Rect2Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsVector3*: proc (self: GodotVariant): Vector3Data + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform2D*: proc (self: GodotVariant): Transform2DData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsPlane*: proc (self: GodotVariant): PlaneData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsQuat*: proc (self: GodotVariant): QuatData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsAABB*: proc (self: GodotVariant): AABBData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsBasis*: proc (self: GodotVariant): BasisData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsTransform*: proc (self: GodotVariant): TransformData + {.noconv, raises: [], gcsafe, tags: [], locks: 0.} + variantAsColor*: proc (self: GodotVariant): ColorData + {.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 + 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.} + 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 + {.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.} + 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) + {.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.} + +{.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: + 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) +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: + let typ = GDNativeAPIType(header.typ) + case typ: + of GDNativeCore: + let coreApi = cast[ptr GDNativeCoreAPI1](apiStruct) + if coreApi[].version.major == 1 and coreApi[].version.minor == 0: + 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 + poolByteArrayRead + poolByteArrayWrite + poolByteArraySet + poolByteArrayGet + poolByteArraySize + poolByteArrayDestroy + + # PoolIntArray API + poolIntArrayNew + poolIntArrayNewCopy + poolIntArrayNewWithArray + poolIntArrayAppend + poolIntArrayAppendArray + poolIntArrayInsert + poolIntArrayInvert + poolIntArrayPushBack + poolIntArrayRemove + poolIntArrayResize + poolIntArrayRead + poolIntArrayWrite + poolIntArraySet + poolIntArrayGet + poolIntArraySize + poolIntArrayDestroy + + # PoolRealArray API + poolRealArrayNew + poolRealArrayNewCopy + poolRealArrayNewWithArray + poolRealArrayAppend + poolRealArrayAppendArray + poolRealArrayInsert + poolRealArrayInvert + poolRealArrayPushBack + poolRealArrayRemove + poolRealArrayResize + poolRealArrayRead + poolRealArrayWrite + poolRealArraySet + poolRealArrayGet + poolRealArraySize + poolRealArrayDestroy + + # PoolStringArray API + poolStringArrayNew + poolStringArrayNewCopy + poolStringArrayNewWithArray + poolStringArrayAppend + poolStringArrayAppendArray + poolStringArrayInsert + poolStringArrayInvert + poolStringArrayPushBack + poolStringArrayRemove + poolStringArrayResize + poolStringArrayRead + poolStringArrayWrite + poolStringArraySet + poolStringArrayGet + poolStringArraySize + poolStringArrayDestroy + + + # PoolVector2 API + poolVector2ArrayNew + poolVector2ArrayNewCopy + poolVector2ArrayNewWithArray + poolVector2ArrayAppend + poolVector2ArrayAppendArray + poolVector2ArrayInsert + poolVector2ArrayInvert + poolVector2ArrayPushBack + poolVector2ArrayRemove + poolVector2ArrayResize + poolVector2ArrayRead + poolVector2ArrayWrite + poolVector2ArraySet + poolVector2ArrayGet + poolVector2ArraySize + poolVector2ArrayDestroy + + # PoolVector3 API + poolVector3ArrayNew + poolVector3ArrayNewCopy + poolVector3ArrayNewWithArray + poolVector3ArrayAppend + poolVector3ArrayAppendArray + poolVector3ArrayInsert + poolVector3ArrayInvert + poolVector3ArrayPushBack + poolVector3ArrayRemove + poolVector3ArrayResize + poolVector3ArrayRead + poolVector3ArrayWrite + poolVector3ArraySet + poolVector3ArrayGet + poolVector3ArraySize + poolVector3ArrayDestroy + + # PoolColorArray API + poolColorArrayNew + poolColorArrayNewCopy + poolColorArrayNewWithArray + poolColorArrayAppend + poolColorArrayAppendArray + poolColorArrayInsert + poolColorArrayInvert + poolColorArrayPushBack + poolColorArrayRemove + poolColorArrayResize + poolColorArrayRead + poolColorArrayWrite + 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 + arrayBSearch + arrayBSearchCustom + arrayDestroy + + # Pool Array Read/Write Access API + + poolByteArrayReadAccessCopy + poolByteArrayReadAccessPtr + poolByteArrayReadAccessOperatorAssign + poolByteArrayReadAccessDestroy + + poolIntArrayReadAccessCopy + poolIntArrayReadAccessPtr + poolIntArrayReadAccessOperatorAssign + poolIntArrayReadAccessDestroy + + poolRealArrayReadAccessCopy + poolRealArrayReadAccessPtr + poolRealArrayReadAccessOperatorAssign + poolRealArrayReadAccessDestroy + + poolStringArrayReadAccessCopy + poolStringArrayReadAccessPtr + poolStringArrayReadAccessOperatorAssign + poolStringArrayReadAccessDestroy + + poolVector2ArrayReadAccessCopy + poolVector2ArrayReadAccessPtr + poolVector2ArrayReadAccessOperatorAssign + poolVector2ArrayReadAccessDestroy + + poolVector3ArrayReadAccessCopy + poolVector3ArrayReadAccessPtr + poolVector3ArrayReadAccessOperatorAssign + poolVector3ArrayReadAccessDestroy + + poolColorArrayReadAccessCopy + poolColorArrayReadAccessPtr + poolColorArrayReadAccessOperatorAssign + poolColorArrayReadAccessDestroy + + poolByteArrayWriteAccessCopy + poolByteArrayWriteAccessPtr + poolByteArrayWriteAccessOperatorAssign + poolByteArrayWriteAccessDestroy + + poolIntArrayWriteAccessCopy + poolIntArrayWriteAccessPtr + poolIntArrayWriteAccessOperatorAssign + poolIntArrayWriteAccessDestroy + + poolRealArrayWriteAccessCopy + poolRealArrayWriteAccessPtr + poolRealArrayWriteAccessOperatorAssign + poolRealArrayWriteAccessDestroy + + poolStringArrayWriteAccessCopy + poolStringArrayWriteAccessPtr + poolStringArrayWriteAccessOperatorAssign + poolStringArrayWriteAccessDestroy + + poolVector2ArrayWriteAccessCopy + poolVector2ArrayWriteAccessPtr + poolVector2ArrayWriteAccessOperatorAssign + poolVector2ArrayWriteAccessDestroy + + poolVector3ArrayWriteAccessCopy + poolVector3ArrayWriteAccessPtr + poolVector3ArrayWriteAccessOperatorAssign + poolVector3ArrayWriteAccessDestroy + + poolColorArrayWriteAccessCopy + poolColorArrayWriteAccessPtr + poolColorArrayWriteAccessOperatorAssign + poolColorArrayWriteAccessDestroy + + # 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 + nodePathGetConcatenatedSubnames + 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 + + # 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 + 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 + transformXformAABB + transformXformInvAABB + + # 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 + variantNewAABB + 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 + variantAsAABB + variantAsBasis + variantAsTransform + variantAsColor + variantAsNodePath + variantAsRID + variantAsObject + variantAsDictionary + variantAsArray + variantAsPoolByteArray + variantAsPoolIntArray + variantAsPoolRealArray + variantAsPoolStringArray + variantAsPoolVector2Array + variantAsPoolVector3Array + variantAsPoolColorArray + variantCall + variantHasMethod + variantOperatorEqual + variantOperatorLess + variantHashCompare + variantBooleanize + variantDestroy + + # String API + charStringLength + charStringGetData + charStringDestroy + + stringNew + stringNewCopy + stringWideStr + stringOperatorEqual + stringOperatorLess + stringOperatorPlus + stringLength + stringDestroy + stringUtf8 + stringCharsToUtf8 + stringCharsToUtf8WithLen + + # Misc API + objectDestroy + globalGetSingleton + methodBindGetMethod + methodBindPtrCall + methodBindCall + getClassConstructor + + alloc + realloc + free + + printError + printWarning + print + + foundCoreApi = true + for i in 0.cuint..= (0, 19, 0): + import compiler/lineinfos + +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) + result = PNode(kind: nkIdent, ident: getIdent(ident)) + +proc newPNode(kind: TNodeKind): PNode = + 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: @@ -15,37 +34,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) @@ -54,66 +73,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 @@ -139,19 +158,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 @@ -206,42 +225,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 not doc.isNil: - let recList = newNode(nkRecList) - let docNode = newNode(nkCommentStmt) + if doc.len > 0: + 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) @@ -251,7 +270,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) @@ -259,46 +278,63 @@ 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 typ: GodotType args: seq[MethodArg] - returnType: string + returnType: Option[string] isVirtual: bool isBase: bool isDiscardable: bool -const standardTypes = toSet( +const standardTypes = toHashSet( ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32", - "uint64", + "uint64", "Error", "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"]) -const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", - "int32", "cint", "int", "Error"]) -const int64Types = toSet(["uint64", "int64"]) +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"]) 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) + assert(typ in wrapperTypes or typ == "Object") result = newDotExpr(varName, ident("godot" & typ)) proc newNilCheck(ident, toAssign: PNode): PNode = newIfStmt(newCall("isNil", ident), - newNode(nkAsgn).addChain(ident).addChain( + newPNode(nkAsgn).addChain(ident).addChain( toAssign ) ) @@ -309,6 +345,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: @@ -325,15 +362,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'): @@ -342,23 +379,58 @@ 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 + elif arg.typ == "Dictionary": + result = newCall("newDictionary") + 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 = + "godotBoundArg" & $idx + 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] @@ -369,12 +441,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) @@ -383,94 +455,138 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string], newCall("getMethod", newCStringLit(meth.typ.godotName), newCStringLit(meth.godotName)) ) - let vars = newNode(nkVarSection) - var varargsName: string + let vars = newPNode(nkVarSection) + var varargsName = none(string) var isVarargs: bool var staticArgsLen: int var argLenNode = newIntLit(0) let argsName = ident("argsToPassToGodot") if meth.args.len > 0: - for arg in meth.args: - if arg.isVarargs: - varargsName = arg.name + for idx, arg in meth.args: + if arg.kind == ArgKind.VarArgs: + varargsName = some(arg.name) isVarargs = true vars.add(newIdentDefs(ident("callError"), ident("VariantCallError"))) - break - let argsAlloc = newNode(nkCast).addChain( - newNode(nkPtrTy).addChain( - newNode(nkBracketExpr).addChain( + elif arg.kind == ArgKind.Bound: + let argName = boundArgName(idx) + vars.add(newIdentDefs( + ident(argName), newPNode(nkEmpty), arg.makeDefaultValue())) + + 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.isNil: meth.args.len + staticArgsLen = if varargsName.isNone: 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)))) + newCall("sizeof", newPNode(nkPtrTy).addChain(ident("GodotVariant"))), ident("*"), + 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) + let destructors = newPNode(nkStmtList) for idx, arg in meth.args: - var argName = ident(arg.name) - if arg.isVarargs: - argName = newNode(nkBracketExpr).addChain( - ident(varargsName), + var argName = if arg.kind == ArgKind.Bound: ident(boundArgName(idx)) + else: ident(arg.name) + if arg.kind == ArgKind.VarArgs: + argName = newPNode(nkBracketExpr).addChain( + ident(varargsName.get), 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: - 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 - if not isStandardType and arg.isVarargs: + 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 $#" % [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( + argConversions.add(newPNode(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), + let objVal = newIfStmt( + prefix("not", newDotExpr(argName, ident"isNil")), + newDotExpr(argName, ident("godotObject")) + ).addChain(newPNode(nkElse).addChain(newNilLit())) + argConversions.add(newPNode(nkLetSection).addChain( + newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), objVal))) + let argAsgn = newPNode(nkAsgn).addChain( + newPNode(nkBracketExpr).addChain( + newPNode(nkBracketExpr).addChain(argsName), argIdx), convArg ) - if not arg.isVarargs: + if arg.kind != ArgKind.VarArgs: argConversions.add( 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")))) @@ -479,26 +595,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) @@ -508,126 +624,135 @@ 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( + body.add(newPNode(nkVarSection).addChain(newIdentDefs( retValIdent, ident("int64"), ))) - elif meth.returnType in float32Types: + elif returnType in float32Types: isConversionRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( + body.add(newPNode(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), + body.add(newPNode(nkVarSection).addChain(newIdentDefs( + retValIdent, ident("Godot" & returnType), ))) - elif meth.returnType in standardTypes: + if returnType != "NodePath": + body.add(newCall("initGodot" & returnType, retValIdent)) + elif returnType in standardTypes: addrToAssign = newCall("addr", ident("result")) - elif meth.returnType == "string": + elif returnType == "string": isStringRet = true - body.add(newNode(nkVarSection).addChain(newIdentDefs( + body.add(newPNode(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")), + 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 not meth.returnType.isNil: + 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.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: - body.add(freeCall) - if not varargsName.isNil: + 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"))), - 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, retValIdent))) + newCall(meth.returnType.get, retValIdent))) elif isWrapperRet: - body.add(newNode(nkAsgn).addChain( + body.add(newPNode(nkAsgn).addChain( ident("result"), - newCall("new" & meth.returnType, retValIdent))) + 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))) + 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 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)) + params.add(newPNode(nkEmpty)) if not meth.typ.isSingleton: 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), + newPNode(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) 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 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) @@ -636,45 +761,8 @@ proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string], meth: MethodInfo, withImplementation: bool) = doGenerateMethod(tree, methodBindRegistry, meth, 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) - 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], - 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) +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: @@ -690,14 +778,16 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, 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((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) @@ -706,8 +796,11 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, if meth["name"].str == '_' & godotName: nimName = nimName & "Impl" - const discardableMethods = toSet(["emit_signal"]) - let methodInfo = MethodInfo( + let returnType = if methodObj["return_type"].str != "void": + some(toNimType(types, methodObj["return_type"].str)) + else: none(string) + const discardableMethods = toHashSet(["emit_signal"]) + result = MethodInfo( name: ident(nimName), typ: typ, godotName: methodObj["name"].str, @@ -719,6 +812,71 @@ proc makeMethod(types: Table[string, GodotType], tree: PNode, 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, 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 = newPNode(nkAccQuoted).addChain(ident(getterNameStr & "=")) + + let getter = findMethod(obj, propertyObj["getter"].str) + let nimType = if getter.isNil: toNimType(types, propertyObj["type"].str) + else: getMethodInfo(getter, types, typ).returnType.get("void") + let getterInfo = MethodInfo( + name: getterName, + typ: typ, + godotName: propertyObj["getter"].str, + args: newSeq[MethodArg](), + returnType: some(nimType) + ) + let setterInfo = MethodInfo( + name: setterName, + typ: typ, + godotName: propertyObj["setter"].str, + 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) + +proc makeMethod(types: Table[string, GodotType], tree: PNode, + methodBindRegistry: var HashSet[string], + typ: GodotType, methodObj: JsonNode, + withImplementation: bool) = + 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: + 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) + generateMethod(tree, methodBindRegistry, methodInfo, withImplementation) proc addAttributeToDoc(doc: var string, propName, propValue: string) = @@ -751,15 +909,15 @@ proc typeNameToModuleName(name: string): string = proc newRegisterClassNode(typ: GodotType): PNode = newCall("registerClass", ident(typ.name), - newCStringLit(typ.godotName), + newStrLit(typ.godotName), ident("true") # isNative ) 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 = @@ -776,9 +934,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: @@ -789,7 +947,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) @@ -800,10 +958,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, @@ -832,7 +990,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: @@ -853,17 +1011,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) @@ -895,16 +1053,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, + obj, 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, obj, withImplementation = true) for meth in obj["methods"]: makeMethod(types, tree, methodBindRegsitry, typ, meth, withImplementation = true) @@ -922,7 +1082,6 @@ when isMainModule: import os const usage = """Tool for wrapping Godot API into Nim - godotapigen [godot binary path] [target directory]""" proc main() = @@ -953,4 +1112,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 c89ea6c..207d76f 100644 --- a/godot/godotinternal.nim +++ b/godot/godotinternal.nim @@ -1,8 +1,8 @@ -# Copyright 2017 Xored Software, Inc. +# 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, @@ -29,8 +29,7 @@ proc nativeScriptRegisterClass*(libHandle: pointer; name, base: cstring; createFunc: GodotInstanceCreateFunc; destroyFunc: GodotInstanceDestroyFunc) {.inline.} = - let api = getGDNativeAPI() - api.nativeScriptRegisterClass( + getGDNativeAPI().nativeScriptRegisterClass( libHandle, name, base, createFunc, destroyFunc) proc nativeScriptRegisterToolClass*(libHandle: pointer; name, base: cstring; @@ -73,8 +72,7 @@ proc deinit*(o: ptr GodotObject) {.inline.} = proc godotPrintError*(description, function, file: cstring; line: cint) {.inline.} = - let api = getGDNativeAPI() - api.printError(description, function, file, line) + getGDNativeAPI().printError(description, function, file, line) proc godotPrintWarning*(description, function, file: cstring; line: cint) {.inline.} = @@ -95,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/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/godotarrays.nim b/godot/internal/godotarrays.nim index 676e6cd..c7e451d 100644 --- a/godot/internal/godotarrays.nim +++ b/godot/internal/godotarrays.nim @@ -1,6 +1,6 @@ -# Copyright (c) 2017 Xored Software, Inc. +# 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) @@ -126,21 +126,30 @@ 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..= ownLen: + let instInfo = instantiationInfo() + getGDNativeAPI().printError( + cstring"Invalid subarray begin index", cstring"subarray", instInfo.filename, instInfo.line.cint) + return + if actualIdxTo < 0 or actualIdxTo >= ownLen: + let instInfo = instantiationInfo() + getGDNativeAPI().printError( + cstring"Invalid subarray end index", cstring"subarray", instInfo.filename, instInfo.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 +128,13 @@ genPoolArrayAPI(GodotPoolByteArray, initGodotPoolByteArray, byte, poolByteArraySet, poolByteArrayGet, poolByteArraySize, - poolByteArrayDestroy) + poolByteArrayDestroy, + poolByteArrayRead, + poolByteArrayWrite, + poolByteArrayReadAccessPtr, + poolByteArrayWriteAccessPtr, + poolByteArrayReadAccessDestroy, + poolByteArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint, poolIntArrayNew, @@ -86,7 +150,13 @@ genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint, poolIntArraySet, poolIntArrayGet, poolIntArraySize, - poolIntArrayDestroy) + poolIntArrayDestroy, + poolIntArrayRead, + poolIntArrayWrite, + poolIntArrayReadAccessPtr, + poolIntArrayWriteAccessPtr, + poolIntArrayReadAccessDestroy, + poolIntArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32, poolRealArrayNew, @@ -102,7 +172,13 @@ genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32, poolRealArraySet, poolRealArrayGet, poolRealArraySize, - poolRealArrayDestroy) + poolRealArrayDestroy, + poolRealArrayRead, + poolRealArrayWrite, + poolRealArrayReadAccessPtr, + poolRealArrayWriteAccessPtr, + poolRealArrayReadAccessDestroy, + poolRealArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString, poolStringArrayNew, @@ -118,7 +194,13 @@ genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString, poolStringArraySet, poolStringArrayGet, poolStringArraySize, - poolStringArrayDestroy) + poolStringArrayDestroy, + poolStringArrayRead, + poolStringArrayWrite, + poolStringArrayReadAccessPtr, + poolStringArrayWriteAccessPtr, + poolStringArrayReadAccessDestroy, + poolStringArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2, poolVector2ArrayNew, @@ -134,7 +216,13 @@ genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2, poolVector2ArraySet, poolVector2ArrayGet, poolVector2ArraySize, - poolVector2ArrayDestroy) + poolVector2ArrayDestroy, + poolVector2ArrayRead, + poolVector2ArrayWrite, + poolVector2ArrayReadAccessPtr, + poolVector2ArrayWriteAccessPtr, + poolVector2ArrayReadAccessDestroy, + poolVector2ArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3, poolVector3ArrayNew, @@ -150,7 +238,13 @@ genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3, poolVector3ArraySet, poolVector3ArrayGet, poolVector3ArraySize, - poolVector3ArrayDestroy) + poolVector3ArrayDestroy, + poolVector3ArrayRead, + poolVector3ArrayWrite, + poolVector3ArrayReadAccessPtr, + poolVector3ArrayWriteAccessPtr, + poolVector3ArrayReadAccessDestroy, + poolVector3ArrayWriteAccessDestroy) genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color, poolColorArrayNew, @@ -166,4 +260,10 @@ genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color, poolColorArraySet, poolColorArrayGet, poolColorArraySize, - poolColorArrayDestroy) + poolColorArrayDestroy, + poolColorArrayRead, + poolColorArrayWrite, + poolColorArrayReadAccessPtr, + poolColorArrayWriteAccessPtr, + poolColorArrayReadAccessDestroy, + poolColorArrayWriteAccessDestroy) diff --git a/godot/internal/godotstrings.nim b/godot/internal/godotstrings.nim index e5529e5..e67acfd 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 @@ -8,19 +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) - -proc cstring*(self: GodotString): cstring {.inline.} = - getGDNativeAPI().stringCStr(self) + dest = getGDNativeAPI().stringCharsToUtf8WithLen(contents, size) proc `==`*(self, b: GodotString): bool {.inline.} = getGDNativeAPI().stringOperatorEqual(self, b) @@ -34,20 +22,29 @@ 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 length = self.len - result = newStringOfCap(length) - getData(self, addr result[0], length) - result.setLen(length) - assert(result[length] == '\0') + var charStr = getGDNativeAPI().stringUtf8(self) + let length = getGDNativeAPI().charStringLength(charStr) + result = newString(length) + copyMem(addr result[0], getGDNativeAPI().charStringGetData(charStr), length) + getGDNativeAPI().charStringDestroy(charStr) proc toGodotString*(s: string): GodotString {.inline.} = ## Converts the Nim string into ``GodotString`` - if s.isNil: - initGodotString(result) + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + if s.isNil: + initGodotString(result) + else: + initGodotString(result, cstring(s), cint(s.len + 1)) 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/internal/godotvariants.nim b/godot/internal/godotvariants.nim index 5e9ebb8..0a0980f 100644 --- a/godot/internal/godotvariants.nim +++ b/godot/internal/godotvariants.nim @@ -1,6 +1,6 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. -import core.godotcoretypes, godotinternaltypes, gdnativeapi +import core/godotcoretypes, godotinternaltypes, gdnativeapi proc getType*(p: GodotVariant): VariantType {.inline.} = getGDNativeAPI().variantGetType(p) @@ -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) @@ -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 asRect3*(self: GodotVariant): Rect3 {.inline.} = - getGDNativeAPI().variantAsRect3(self) +proc asAABB*(self: GodotVariant): AABB {.inline.} = + 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) diff --git a/godot/nim/godotmacros.nim b/godot/nim/godotmacros.nim index d484f4d..6b81f7e 100644 --- a/godot/nim/godotmacros.nim +++ b/godot/nim/godotmacros.nim @@ -1,8 +1,8 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. -import macros, tables, typetraits -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 @@ -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 @@ -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) @@ -51,14 +53,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 == !"of"): + if not (definition.kind == nnkInfix and + 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") @@ -71,13 +74,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.} = @@ -90,9 +93,8 @@ proc removePragmaNode(statement: NimNode, 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: + if ident.eqIdent(pname): pragmas.del(i) return val @@ -103,19 +105,18 @@ proc removePragma(statement: NimNode, pname: string): bool = return false 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: + if ident.eqIdent(pname): pragmas.del(i) 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: @@ -171,10 +172,15 @@ proc parseMethod(meth: NimNode): MethodDecl = proc parseVarSection(decl: NimNode): seq[VarDecl] = assert(decl.kind == nnkVarSection) - result = identDefsToVarDecls(decl[0]) + for i in 0..`_ 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 0b0a765..7f3ed96 100644 --- a/godot/nim/godotnim.nim +++ b/godot/nim/godotnim.nim @@ -1,14 +1,14 @@ -# Copyright 2017 Xored Software, Inc. +# Copyright 2018 Xored Software, Inc. -import tables, typetraits, macros, asyncdispatch +import tables, typetraits, macros, unicode, strutils, sets, options import gdnativeapi -import core.godotcoretypes -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 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`` @@ -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 @@ -57,7 +59,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 @@ -89,40 +91,71 @@ type ## values. ## See documentation of ``GodotPropertyHint`` for description of formats. + FNV1Hash = uint32 + +include "internal/backwardcompat.inc.nim" + 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] +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)) and 0xFFFFFFFF'u32).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() @@ -140,6 +173,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. @@ -147,12 +187,15 @@ 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 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 = @@ -166,7 +209,7 @@ macro baseNativeType(T: typedesc): cstring = if typeName == "NimGodotObject": break t = getType(t[1][1]) - if baseT.isNil: + if baseT.len == 0: result = newNilLit() else: let rStr = newNimNode(nnkRStrLit) @@ -191,12 +234,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]) @@ -210,14 +253,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) @@ -226,10 +277,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,7 +291,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. @@ -252,8 +303,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()), forceNativeObject) + godotObject, classNameStr, + forceNativeObject or noRef) + deinit(classNameStr) proc newVariant*(obj: NimGodotObject): Variant {.inline.} = newVariant(obj.godotObject) @@ -278,45 +332,35 @@ 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): - printError("Failed to cast object to " & - 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) result.strVal = s -static: - import strutils - -macro toGodotName(T: typedesc): string = - var godotName: string +macro toGodotName(T: typedesc): untyped = if T is GodotString or T is string: - godotName = "String" + newStrLitNode"String" elif T is SomeFloat: - godotName = "float" + newStrLitNode"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 = newLit(godotName) + newStrLitNode"int" + else: + let nameStr = ((T.getType()[1][1].strVal).split(':')[0]) + case nameStr: + of "File", "Directory", "Thread", "Mutex", "Semaphore": + newStrLitNode("_" & nameStr) + else: + newStrLitNode(nameStr) macro asCString(s: static[string]): cstring = result = newNimNode(nnkCallStrLit).add( @@ -375,11 +419,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] - result = when objInfo.isNative: - asNimGodotObject[T](getClassConstructor(godotName)()) - else: newOwnObj[T](godotName) + const godotName = toGodotName(T) + const cGodotName = asCString(godotName) + const objInfo = classRegistryStatic[fnv1Hash(godotName)] + when objInfo.isNative: + let godotObject = getClassConstructor(cGodotName)() + new(result, nimGodotObjectFinalizer[T]) + result.godotObject = godotObject + when objInfo.isRef: + godotObject.initRef() + result.isRef = true + else: + result = newOwnObj[T](cGodotName) proc newCallError*(err: VariantCallError): ref CallError = ## Instantiates ``CallError`` from Godot ``err``. @@ -419,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. @@ -469,7 +523,7 @@ proc toVariant*(self: Variant): Variant {.inline.} = if self.isNil: newVariant() else: - self + newVariant(self) proc fromVariant*(self: var Variant, val: Variant): ConversionResult {.inline.} = @@ -497,8 +551,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: @@ -558,7 +612,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) @@ -614,8 +672,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: @@ -662,7 +720,10 @@ proc fromVariant*(s: var string, val: Variant): ConversionResult = if val.getType() == VariantType.String: s = val.asString() elif val.getType() == VariantType.Nil: - s = nil + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + s = nil + else: + s = "" else: result = ConversionResult.TypeError @@ -736,10 +797,31 @@ 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](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 -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() @@ -749,7 +831,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: @@ -759,8 +841,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()) @@ -778,10 +864,11 @@ proc fromVariant*[T: Table or TableRef](t: var T, else: result = ConversionResult.TypeError -{.emit: """/*TYPESECTION*/ -void NimMain(void); -N_NOINLINE(void, 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); + """.} var nativeLibHandle: pointer proc getNativeLibHandle*(): pointer = @@ -794,31 +881,60 @@ proc godot_nativescript_init(handle: pointer) {. nativeLibHandle = handle var stackBottom {.volatile.}: pointer + stackBottom = addr(stackBottom) {.emit: """ NimMain(); - setStackBottom((void*)(&`stackBottom`)); """.} + when (NimMajor, NimMinor, NimPatch) < (0, 19, 0): + {.emit: """ + setStackBottom((void*)(&`stackBottom`)); + """.} + else: + nimGC_setStackBottom(stackBottom) GC_fullCollect() GC_disable() -proc godot_gdnative_init(options: ptr GodotNativeInitOptions) {. +proc godot_gdnative_init(options: ptr GDNativeInitOptions) {. cdecl, exportc, dynlib.} = gdNativeLibraryObj = options.gdNativeLibrary - setGDNativeAPI(options.gdNativeAPIStruct) + setGDNativeAPI(options.gdNativeAPIStruct, options) -proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. +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 + +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) + +{.push stackTrace: off.} + proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} = var stackBottom {.volatile.}: pointer - {.emit: """ - setStackBottom((void*)(&`stackBottom`)); - """.} - for _ in 1..10: - if asyncdispatch.hasPendingOperations(): - poll(0) + 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) when not defined(release): @@ -829,7 +945,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() @@ -837,3 +953,5 @@ proc godot_nativescript_thread_enter() {.cdecl, exportc, dynlib.} = proc godot_nativescript_thread_exit() {.cdecl, exportc, dynlib.} = when compileOption("threads"): teardownForeignThreadGc() + +{.pop.} # stackTrace: off diff --git a/godot/nim/nim.cfg b/godot/nim/nim.cfg index f1fb6a7..add9a4d 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