.gitignore

@@ -1,14 +1,4 @@
 nimcache/
-
+.DS_Store
 /godot/apigen/apigen
 /godot/apigen/apigen.exe
-/godot/godotapigen
-/godot/godotapigen.exe
-
-/docgen
-/docs/docbuild
-/docs/docbuild.exe
-/docs/docpublish
-/docs/docpublish.exe
-
-.DS_Store

.travis.yml

@@ -1,53 +0,0 @@
-sudo: false
-language: c
-os:
-  - osx
-compiler: clang
-env:
-  global:
-    - secure: o+IZkRS6J7bGYkiilm10KDeCTDIVHszZ9dPvb93cdUKX/9hFVRiUjDOvNXqBdyOv43JIAsRTppym4B2pfcp9cwLoVBJNW70GKhp6ChLZm3wFdabScWKemuG2YtAUyGiSmxbVmUZ4baltnADyGFHuYWgHLjx6AKO26SqrXRLJ0I1IzGNKKNIfoyZzm7qdFDGJRnSC7L+y1pOITK7dpy60D1vat4FhOLaz2K7L8T8tZYZFK7yyxKduFUlY3cy4z3TpjxMa9/ksCiPiuPDN5xOrVIw0AtgZ2gYodZJUEnfaRzFkgcZ4OJuTAMNMalu52mVAVAoDt4yc7BnbtfsYJzfIjTeLjjWKWz8mqqp/HpxcfVnmPKxV5zeN8UhbosT8vNjwretWbQcFndzt0ohK7E8uMsnDGER7sGPEhCZCttkId96gi7Ro1awPIKCqLaMqB43Bwo48nnW0oQgrfWe1ZKtREXWI4F1F2GMbU8Jsvv0N5GnPGd4RDieBH5KIkJXcttAwRk8AUQ4U5PVkQ/OK9xm9BH2tB0vrjZ4FZWnFPapKVcPUYw9deyyXOXwSMmDpuwkJIjqi3tRyBWJG9+tUlAJw8zyFkCPeN9kzyVH/PhbacwBMdSxew24VLAWWCUhQHCP+fcjpKio8uDUFQN3javIRV4N3mHJ9v0VAF7Ixzh8AviQ=
-
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-3.9
-    packages:
-      - build-essential
-      - scons
-      - pkg-config
-      - libx11-dev
-      - libxcursor-dev
-      - libasound2-dev
-      - libfreetype6-dev
-      - libgl1-mesa-dev
-      - libglu1-mesa-dev
-      - libssl-dev
-      - libxinerama-dev
-      - libxrandr-dev
-
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then 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
-  - git clone --depth=1 https://github.com/nim-lang/Nim.git
-  - cd Nim
-  - git checkout devel
-  - sh ci/build.sh
-  - export PATH=$PATH:"`pwd`/bin"
-  - ./koch tools -d:release
-  - nimble install -y
-  - cd ..
-  - git clone --depth=1 https://github.com/godotengine/godot.git godotengine
-  - cd godotengine
-  - scons -j 3 platform=$GODOT_PLATFORM
-  - export GODOT_BIN="`pwd`/bin/godot.$GODOT_PLATFORM.tools.64"
-  - cd ..
-
-script:
-  - set -e
-  - mkdir godotapi
-  - nim c -d:release -r godot/godotapigen.nim "$GODOT_BIN" godotapi
-  - nim c -d:useRealtimeGc --path:godot -c godotapi/godotall.nim
-  - nim c -d:release -r docs/docpublish.nim

.vscode/settings.json

@@ -6,10 +6,10 @@
   "files.eol": "\n",
   "files.trimTrailingWhitespace": true,
   "nim.project": ["godot/godot.nim",
-                  "godot/godotapigen.nim"],
+                  "godot/apigen/apigen.nim"],
   "nim.buildOnSave": false,
   "nim.lintOnSave": true,
-  "nim.licenseString": "# Copyright 2018 Xored Software, Inc.\n\n",
+  "nim.licenseString": "# Copyright 2017 Xored Software, Inc.\n\n",
   "files.exclude": {
     "**/nimcache/**": true
   }

LICENSE

@@ -2,7 +2,7 @@ godot-nim - Nim bindings for Godot Engine
 
 The MIT License
 
-Copyright (c) 2018 Xored Software Inc.
+Copyright (c) 2017 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,

README.md

@@ -1,8 +1,6 @@
 # Nim bindings for Godot Engine
 
-Nim bindings for Godot 3 based on [GDNative](https://godotengine.org/article/dlscript-here).
-
-Documentation: https://pragmagic.github.io/godot-nim/
+Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here).
 
 ## Links
 
@@ -11,6 +9,6 @@ Documentation: https://pragmagic.github.io/godot-nim/
 
 ## License
 
-This project is licensed under the MIT license. Read [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT license. Read [LICENSE](https://github.com/pragmagic/godot-nim/blob/master/LICENSE) file for details.
 
-Copyright (c) 2018 Xored Software, Inc.
+Copyright (c) 2017 Xored Software, Inc.

docs/docbuild.nim

@@ -1,161 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import threadpool, os, osproc, strutils, sequtils, pegs
-
-import "../godot/godotapigen.nim"
-
-const dirs = ["godot"/"core", "godot"/"internal", "godot"/"nim"]
-const files = ["godot"/"godotapigen.nim", "godot"/"godotinternal.nim",
-               "godot"/"godot.nim"]
-const indexFile = "docs"/"index.rst"
-const gitHubUrl = "https://github.com/pragmagic/godot-nim"
-
-proc outName(outDir, file: string): string =
-  outDir / file.extractFilename().changeFileExt("html")
-
-template quoted(s: string): string =
-  ('"' & s & '"')
-
-proc execOrFail(cmd: string) =
-  echo "[exec] " & cmd
-  let ret = execShellCmd(cmd)
-  if ret != 0:
-    raise newException(
-      Exception, "Command quit with exit code " & $ret & ": " & cmd)
-
-template withDir(dir: string, body: typed) =
-  let curDir = getCurrentDir()
-  setCurrentDir(dir)
-  try:
-    body
-  finally:
-    setCurrentDir(curDir)
-
-iterator walkDirRec(dir: string, filter: set[PathComponent],
-                    extensions: openarray[string]): string =
-  for file in walkDirRec(dir, filter):
-    if not extensions.anyIt(file.endsWith(it)): continue
-    yield file
-
-proc genApiFiles(targetDir, godotBin: string) =
-  let jsonFile = targetDir / "api.json"
-  try:
-    execOrFail(quoted(godotBin) &
-               " --gdnative-generate-json-api " & quoted(jsonFile))
-  except:
-    # this fails unstably even if api.json is created successfully
-    discard
-  if not fileExists(jsonFile):
-    raise newException(Exception, "Failed to generate Godot API wrappers")
-
-  genApi(targetDir, jsonFile)
-
-  writeFile(targetDir / "nim.cfg", "path=\"$projectdir/../../godot\"")
-
-proc extractVersion(nimbleFile: string): string =
-  let contents = readFile(nimbleFile)
-  var matches: array[1, string]
-  doAssert match(contents, peg"""'version' \s* '=' \s* '"' {@} '"' """, matches)
-  result = matches[0]
-
-proc fixupHrefs(file: string) =
-  var contents = readFile(file)
-  contents = contents.replacef(
-    peg"""'href="' ('internal'/'core'/'nim') '/' {@} '"' """,
-    "href=\"$#\"")
-  if file.contains("godotapi"):
-    contents = contents.replacef(
-      peg"""'href="' {('godotinternal' / 'godot') '.html"'} """,
-      "href=\"../$#")
-  writeFile(file, contents)
-
-proc getGitHash(): string =
-  result = execProcess("git rev-parse HEAD")
-  if result.len > 0:
-    result = result.replace("\L", "").replace("\r", "")
-
-proc buildDocs*(outDir, godotNimDir, godotBin: string) =
-  removeDir(outDir)
-  createDir(outDir)
-  let outDirAbs = expandFilename(outDir)
-  let godotBinAbs = expandFilename(godotBin)
-
-  setCurrentDir(godotNimDir)
-
-  let godotNimVersion = extractVersion("godot.nimble")
-  putEnv("godotnimversion", godotNimVersion)
-  putEnv("godotnimgithub", gitHubUrl)
-  let gitCommit = getGitHash()
-
-  var allNimFiles = newSeq[string]()
-  allNimFiles.add(files)
-  for dir in dirs:
-    for file in walkDirRec(dir, {pcFile, pcDir}, [".nim"]):
-      allNimFiles.add(file)
-  for file in allNimFiles:
-    spawn execOrFail(
-      "nim doc -d:useRealtimeGc --path:godot -o:" &
-      quoted(outName(outDirAbs, file)) &
-      " --git.url:" & quoted(gitHubUrl) &
-      " --git.commit:" & quoted(gitCommit) &
-      ' ' & quoted(file))
-
-  let godotApiFolder = outDirAbs / "godotapi"
-  createDir(godotApiFolder)
-  genApiFiles(godotApiFolder, godotBinAbs)
-  for file in walkDirRec(godotApiFolder, {pcFile, pcDir}, [".nim"]):
-    spawn execOrFail("nim doc -d:useRealtimeGc --path:godot -o:" &
-                     quoted(outName(godotApiFolder, file)) & ' ' & quoted(file))
-
-  sync()
-
-  var gitHash: string
-  withDir(godotBinAbs.parentDir()):
-    gitHash = getGitHash()
-    if gitHash.len == 0:
-      raise newException(Exception,
-        "Godot executable is not under Git repository")
-
-  var indexContent = readFile(indexFile)
-  var apiList = newStringOfCap(4096)
-  for file in walkDirRec(godotApiFolder, {pcFile, pcDir}):
-    if not file.endsWith(".html"):
-      removeFile(file)
-    else:
-      let moduleHtml = file.extractFileName()
-      let moduleName = moduleHtml.changeFileExt("")
-      apiList.add("* `" & moduleName & " <godotapi/" & moduleHtml & ">`_\L")
-  indexContent = indexContent.replace("$GODOTAPI_CHANGESET_HASH", gitHash).
-                              replace("$AUTO_GENERATED_GODOTAPI_LIST", apiList).
-                              replace("$GODOTNIM_GITHUB_URL", gitHubUrl)
-
-  let tmpRst = outDirAbs/"index.rst"
-  writeFile(tmpRst, indexContent)
-  try:
-    execOrFail("nim rst2html -o:" & quoted(outName(outDirAbs, tmpRst)) &
-               ' ' & quoted(tmpRst))
-  finally:
-    removeFile(tmpRst)
-
-  for file in walkDirRec(outDir, {pcFile, pcDir}, [".html"]):
-    spawn fixupHrefs(file)
-
-  sync()
-
-when isMainModule:
-  const outDir = "docgen"
-
-  if not fileExists("godot.nimble"):
-    echo "Must be executed from godot-nim root dir"
-    quit(-1)
-
-  let godotBin = getEnv("GODOT_BIN")
-  if godotBin.len == 0:
-    echo "GODOT_BIN environment variable must point to Godot executable"
-    quit(-1)
-
-  try:
-    buildDocs(outDir, getCurrentDir(), godotBin)
-  except:
-    echo getCurrentExceptionMsg()
-    quit(-1)

docs/docpublish.nim

@@ -1,97 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import os, pegs, strutils
-import docbuild
-
-const indexTemplate = """<html>
-<head><title>godot-nim docs index</title></head>
-<body>
-<h1>Documentation of Nim bindings for Godot Engine (<a href="https://github.com/$REPO_SLUG">GitHub</a>)</h1><br/>
-$VERSION_LIST
-</body>
-</html>
-"""
-
-proc execOrQuit(cmd: string) =
-  let ret = execShellCmd(cmd)
-  if ret != 0:
-    quit(ret)
-
-proc walkDirRecRelative(dir: string, cb: proc (file: string), start = "") =
-  for kind, path in walkDir(dir, relative = true):
-    if kind in {pcFile, pcLinkToFile}:
-      cb(if start.len > 0: start / path else: path)
-    elif kind in {pcDir, pcLinkToDir}:
-      let fullPath = if start.len > 0: start / path else: path
-      walkDirRecRelative(dir / fullPath, cb, fullPath)
-
-proc publish(docDir, gitHubToken, repoSlug, branch, tag, changeset: string) =
-  let release = if branch == "master": branch else: tag
-  let commitComment = if release == "master":
-                        "Update master documentation for changeset " & changeset
-                      else:
-                        "Update documentation for " & tag
-
-  const repoDir = "gh-pages"
-  execOrQuit(
-    "git clone --depth=1 --branch=gh-pages https://github.com/$#.git $#" %
-    [repoSlug, repoDir])
-  try:
-    removeDir(repoDir/release)
-    createDir(repoDir/release)
-    var versionList = newStringOfCap(4096)
-    for kind, path in walkDir(repoDir, relative = true):
-      if kind == pcDir and not path.startsWith("."):
-        versionList.add("<a href='$1/index.html'>$1</a><br/>" % path)
-    let index = indexTemplate.replace("$REPO_SLUG", repoSlug).
-                              replace("$VERSION_LIST", versionList)
-    writeFile(repoDir/"index.html", index)
-
-    walkDirRecRelative(docDir) do (file: string):
-      createDir(parentDir(repoDir/release/file))
-      copyFile(docDir/file, repoDir/release/file)
-
-    setCurrentDir(repoDir)
-    try:
-      execOrQuit("git add --all")
-      execOrQuit("git commit -m \"$#\"" % commitComment)
-      execOrQuit("git push -fq \"https://$#@github.com/$#.git\" gh-pages" %
-                [gitHubToken, repoSlug])
-    finally:
-      setCurrentDir("..")
-  finally:
-    removeDir(repoDir)
-
-when isMainModule:
-  proc getEnvOrQuit(key: string): string =
-    result = getEnv(key)
-    if result.len == 0:
-      echo "Expected environment variable: " & key
-      quit(1)
-
-  let pr = getEnv("TRAVIS_PULL_REQUEST")
-  if pr.len > 0 and pr != "false":
-    echo "This is a PR build. Skipping."
-    quit(0)
-
-  let repoSlug = getEnvOrQuit("TRAVIS_REPO_SLUG")
-  let branch = getEnvOrQuit("TRAVIS_BRANCH")
-  let changeset = getEnvOrQuit("TRAVIS_COMMIT")
-  let tag = getEnv("TRAVIS_TAG")
-
-  # let repoSlug = "pragmagic/godot-nim"
-  # let branch = "master"
-  # let changeset = "0fd0101432c1fed1004f50b035fcf74f75f004a8"
-  # let tag = ""
-
-  let gitHubToken = getEnvOrQuit("GITHUB_TOKEN")
-
-  if branch != "master" and not (tag =~ peg"^ 'v' \d+ '.' \d+ '.' \d+ $"):
-    echo "This is not master or tagged changeset. Skipping."
-    quit(0)
-
-  let godotBin = getEnvOrQuit("GODOT_BIN")
-
-  const docDir = "docgen"
-  buildDocs(docDir, getCurrentDir(), godotBin)
-  publish(docDir, gitHubToken, repoSlug, branch, tag, changeset)

docs/godotapi.rst

@@ -1,12 +0,0 @@
-===============
-Godot API (Nim)
-===============
-
-:Godot Git Hash: |godothash|
-
-.. contents::
-
-This is an auto-generated index of Godot API. It's built from Git changeset
-$GODOTAPI_CHANGESET_HASH.
-
-$AUTO_GENERATED_GODOTAPI_LIST

docs/index.rst

@@ -1,173 +0,0 @@
-=============================
-Nim bindings for Godot Engine
-=============================
-
-:Author: Ruslan Mustakov
-:Version: |godotnimversion|
-:GitHub: `$GODOTNIM_GITHUB_URL <$GODOTNIM_GITHUB_URL>`_
-:License: MIT
-
-.. contents::
-
-``godot-nim`` library allows to create games on
-`Godot Engine <https://godotengine.org/>`_ with
-`Nim programming language <https://nim-lang.org/>`_. Nim is a statically typed
-language with an elegant Python-like syntax that compiles to native code.
-It is garbage-collected, but its GC supports real-time mode which this library
-makes use of. It means the GC will never run during game frames and will use
-fixed amount of frame idle time to collect garbage. This leads to no stalls
-and close to zero compromise on performance comparing to native languages with
-manual memory management.
-
-If you are not familiar with Nim yet, it is recommended to go through the
-`official tutorial <https://nim-lang.org/docs/tut1.html>`_.
-
-`VSCode <https://code.visualstudio.com/>`_ is the recommended editor for
-working with Nim code. It is cross-platform and has the excellent
-`nim plugin <https://marketplace.visualstudio.com/items?itemName=kosz78.nim>`_
-that supports most of the features you would expect from an IDE.
-It also has `godot-tools plugin <https://marketplace.visualstudio.com/items?itemName=geequlim.godot-tools>`_
-which adds features for editing GDScript and Godot resource files.
-
-
-Getting Started
-===============
-
-Getting Godot
---------------
-
-The library requires Godot version 3.0, which you can get here:
-https://godotengine.org/download
-
-Installing Nim
--------------
-
-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.
-
-Creating Project
-----------------
-
-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
-
-(you can then delete the .git directory within to untie the project from the
-stub repository)
-
-The stub contains the necessary build configuration to compile your code for
-desktop and mobile platforms, as well as a couple of very simple scenes to
-help you get started. Consult the stub's `README
-<https://github.com/pragmagic/godot-nim-stub>`_ for information about
-compiling the project.
-
-
-Adding Nim to Existing Project
-------------------------------
-
-If you would like to use Nim in an existing project:
-
-1. Copy ``nakefile.nim`` file and ``src`` directory from the stub described
-   in the previous section above your Godot project folder. Adjust paths in
-   build scripts (``nakefile.nim``, ``src/stub.nimble``) according to your
-   own project structure.
-
-2. Copy ``nimlib.gdnlib`` to your Godot project folder. It is a
-   GDNative library resource that contains paths to dynamic libraries
-   compiled by Nim.
-
-Next Steps
-----------
-
-Once you are familiarized with the build process (it's as simple as running
-``nake build`` after you are set up), it is recommended to go through
-`godotmacros <godotmacros.html>`_ and `godotnim <godotnim.html>`_ module
-documentations. They describe special macros and procedures needed to define
-or instantiate Godot objects. After you learned that, the rest is similar to
-using any Nim library. These bindings do not limit any of Nim's capabilities,
-and you can use any Nim types as fields or parameters of Godot objects and
-their procedures (but, obviously, you may not be able to export some of them
-to Godot editor or GDScript, unless you define your own converters).
-
-
-Modules
-=======
-
-The binding library consists of three major modules:
-
-* `godot <#modules-godot-module>`_ - Contains core types and macro definitions.
-  You need to import this in any module that defines or makes use of Godot
-  types.
-
-* `godotinternal <#modules-godotinternal-module>`_ - Contains raw wrappers over
-  few core types, such as ``GodotVariant``, ``GodotString``, ``GodotNodePath``,
-  ``GodotDictionary``, pool arrays. These are used by ``godotapigen`` and macro
-  implementations, and you don't have to use them at all in your code, unless
-  you want to go into low-level details for some reason. Each of those types
-  needs to be destructed manually with ``deinit`` procedure.
-
-* `godotapigen <godotapigen.html>`_ - Wrapper generator based on data from
-  Godot's ``ClassDB``. You only need to use it as a part of the build process.
-
-
-godot Module
-------------
-
-Contains core types and macro definitions. You need to import this in any
-module that defines or makes use of Godot types. The sumbodules below are
-exported and you don't have to import any of them directly.
-
-* `godotnim <godotnim.html>`_ Defines ``NimGodotObject`` and Varaint converters
-  for standard Nim types.
-* `godotmacros <godotmacros.html>`_ Defines ``gdobj`` macro for defining
-  Godot objects.
-* `variants <variants.html>`_ ``Variant`` type represents a "dynamic object"
-  that many Godot procedures make use of.
-* `arrays <arrays.html>`_ Defines ``Array`` of Variants.
-* `basis <basis.html>`_ Defines 3D ``Basis``.
-* `colors <colors.html>`_ Defines ARGB ``Color``.
-* `dictionaries <dictionaries.html>`_ Defines ``Variant`` -> ``Variant``
-  ``Dictionary``.
-* `nodepaths <nodepaths.html>`_ Defines ``NodePath`` - a path to a ``Node``.
-* `planes <planes.html>`_ Defines 3D ``Plane``.
-* `poolarrays <poolarrays.html>`_ Defines pooled arrays: ``PoolByteArray``,
-  ``PoolIntArray``, ``PoolRealArray``, ``PoolVector2Array``,
-  ``PoolVector3Array``, ``PoolColorArray``, ``PoolStringArray``.
-* `quats <quats.html>`_ Defines ``Quat`` (quaternion) describing object
-  rotation in 3D space.
-* `rect2 <rect2.html>`_ Defines ``Rect2`` - a 2D rectangle.
-* `aabb <aabb.html>`_ Defines ``AABB`` - a 3D box.
-* `rids <rids.html>`_ Defines ``RID`` - a resource identifier.
-* `transform2d <transform2d.html>`_ Defines ``Transform2D``.
-* `transforms <transforms.html>`_ Defines ``Transform``.
-* `vector2 <vector2.html>`_ Defines ``Vector2``.
-* `vector3 <vector3.html>`_ Defines ``Vector3``.
-* `godotbase <godotbase.html>`_ Defines ``Error`` type and few common math
-  procedures missing in Nim's standard library.
-
-
-Godot API
----------
-
-This is an auto-generated list of Godot API modules. It's built from Godot
-changeset `$GODOTAPI_CHANGESET_HASH
-<https://github.com/godotengine/godot/commit/$GODOTAPI_CHANGESET_HASH>`_.
-
-$AUTO_GENERATED_GODOTAPI_LIST
-
-
-godotinternal Module
---------------------
-
-Contains low-level wrappers over Godot types that require manual memory
-management. This module is used within ``godot-nim`` implementation and you
-don't need to import it unless you know what you are doing.
-
-* `godotdictionaries <godotdictionaries.html>`_
-* `godotnodepaths <godotnodepaths.html>`_
-* `godotpoolarrays <godotpoolarrays.html>`_
-* `godotstrings <godotstrings.html>`_
-* `godotvariants <godotvariants.html>`_

docs/nim.cfg

@@ -1 +0,0 @@
---threads:on

examples/simple/.gitignore

@@ -0,0 +1,5 @@
+/project/.import
+/project/_dlls
+/nakefile
+/godotapi
+nimcache

examples/simple/README.md

@@ -0,0 +1,11 @@
+Simple project just to demonstrate usage of the library.
+
+Prerequisites:
+
+1. Install [nake](https://github.com/fowlmouth/nake): `nimble install nake -n`.
+2. Ensure `~/.nimble/bin` is in your PATH.
+3. Set `GODOT_BIN` environment varible to point to Godot executable (currently requires Godot fork - see below).
+
+Run `nake build` in this directory to compile for the current platform.
+
+**NOTE:** Currently this only works with `kingdom` branch of Godot fork: https://github.com/endragor/godot. However, there are pending PRs to make this work with Godot mainline version.

examples/simple/godot_headers/godot/array.h

@@ -0,0 +1,122 @@
+/*************************************************************************/
+/*  array.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_ARRAY_H
+#define GODOT_ARRAY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_ARRAY_SIZE];
+} godot_array;
+#endif
+
+#include "pool_arrays.h"
+#include "variant.h"
+
+#include "gdnative.h"
+
+void GDAPI godot_array_new(godot_array *r_dest);
+void GDAPI godot_array_new_copy(godot_array *r_dest, const godot_array *p_src);
+void GDAPI godot_array_new_pool_color_array(godot_array *r_dest, const godot_pool_color_array *p_pca);
+void GDAPI godot_array_new_pool_vector3_array(godot_array *r_dest, const godot_pool_vector3_array *p_pv3a);
+void GDAPI godot_array_new_pool_vector2_array(godot_array *r_dest, const godot_pool_vector2_array *p_pv2a);
+void GDAPI godot_array_new_pool_string_array(godot_array *r_dest, const godot_pool_string_array *p_psa);
+void GDAPI godot_array_new_pool_real_array(godot_array *r_dest, const godot_pool_real_array *p_pra);
+void GDAPI godot_array_new_pool_int_array(godot_array *r_dest, const godot_pool_int_array *p_pia);
+void GDAPI godot_array_new_pool_byte_array(godot_array *r_dest, const godot_pool_byte_array *p_pba);
+
+void GDAPI godot_array_set(godot_array *p_self, const godot_int p_idx, const godot_variant *p_value);
+
+godot_variant GDAPI godot_array_get(const godot_array *p_self, const godot_int p_idx);
+
+godot_variant GDAPI *godot_array_operator_index(godot_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_array_append(godot_array *p_self, const godot_variant *p_value);
+
+void GDAPI godot_array_clear(godot_array *p_self);
+
+godot_int GDAPI godot_array_count(const godot_array *p_self, const godot_variant *p_value);
+
+godot_bool GDAPI godot_array_empty(const godot_array *p_self);
+
+void GDAPI godot_array_erase(godot_array *p_self, const godot_variant *p_value);
+
+godot_variant GDAPI godot_array_front(const godot_array *p_self);
+
+godot_variant GDAPI godot_array_back(const godot_array *p_self);
+
+godot_int GDAPI godot_array_find(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
+
+godot_int GDAPI godot_array_find_last(const godot_array *p_self, const godot_variant *p_what);
+
+godot_bool GDAPI godot_array_has(const godot_array *p_self, const godot_variant *p_value);
+
+godot_int GDAPI godot_array_hash(const godot_array *p_self);
+
+void GDAPI godot_array_insert(godot_array *p_self, const godot_int p_pos, const godot_variant *p_value);
+
+void GDAPI godot_array_invert(godot_array *p_self);
+
+godot_variant GDAPI godot_array_pop_back(godot_array *p_self);
+
+godot_variant GDAPI godot_array_pop_front(godot_array *p_self);
+
+void GDAPI godot_array_push_back(godot_array *p_self, const godot_variant *p_value);
+
+void GDAPI godot_array_push_front(godot_array *p_self, const godot_variant *p_value);
+
+void GDAPI godot_array_remove(godot_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_array_resize(godot_array *p_self, const godot_int p_size);
+
+godot_int GDAPI godot_array_rfind(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
+
+godot_int GDAPI godot_array_size(const godot_array *p_self);
+
+void GDAPI godot_array_sort(godot_array *p_self);
+
+void GDAPI godot_array_sort_custom(godot_array *p_self, godot_object *p_obj, const godot_string *p_func);
+
+void GDAPI godot_array_destroy(godot_array *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_ARRAY_H

examples/simple/godot_headers/godot/basis.h

@@ -0,0 +1,121 @@
+/*************************************************************************/
+/*  basis.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_BASIS_H
+#define GODOT_BASIS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_BASIS_SIZE 36
+
+#ifndef GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_BASIS_SIZE];
+} godot_basis;
+#endif
+
+#include "gdnative.h"
+#include "quat.h"
+#include "vector3.h"
+
+void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis);
+void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi);
+void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler);
+
+godot_string GDAPI godot_basis_as_string(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_inverse(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_transposed(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_orthonormalized(const godot_basis *p_self);
+
+godot_real GDAPI godot_basis_determinant(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_rotated(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+
+godot_basis GDAPI godot_basis_scaled(const godot_basis *p_self, const godot_vector3 *p_scale);
+
+void GDAPI godot_basis_set_scale(godot_basis *p_self, const godot_vector3 *p_scale);
+
+void GDAPI godot_basis_set_rotation_euler(godot_basis *p_self, const godot_vector3 *p_euler);
+
+void GDAPI godot_basis_set_rotation_axis_angle(godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_angle);
+
+godot_vector3 GDAPI godot_basis_get_scale(const godot_basis *p_self);
+
+godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_self);
+
+godot_real GDAPI godot_basis_tdotx(const godot_basis *p_self, const godot_vector3 *p_with);
+
+godot_real GDAPI godot_basis_tdoty(const godot_basis *p_self, const godot_vector3 *p_with);
+
+godot_real GDAPI godot_basis_tdotz(const godot_basis *p_self, const godot_vector3 *p_with);
+
+godot_vector3 GDAPI godot_basis_xform(const godot_basis *p_self, const godot_vector3 *p_v);
+
+godot_vector3 GDAPI godot_basis_xform_inv(const godot_basis *p_self, const godot_vector3 *p_v);
+
+godot_int GDAPI godot_basis_get_orthogonal_index(const godot_basis *p_self);
+
+void GDAPI godot_basis_new(godot_basis *r_dest);
+
+void GDAPI godot_basis_new_with_euler_quat(godot_basis *r_dest, const godot_quat *p_euler);
+
+// p_elements is a pointer to an array of 3 (!!) vector3
+void GDAPI godot_basis_get_elements(godot_basis *p_self, godot_vector3 *p_elements);
+
+godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_self, const godot_int p_axis);
+
+void GDAPI godot_basis_set_axis(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value);
+
+godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_self, const godot_int p_row);
+
+void GDAPI godot_basis_set_row(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value);
+
+godot_bool GDAPI godot_basis_operator_equal(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_add(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_substract(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_multiply_vector(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_multiply_scalar(const godot_basis *p_self, const godot_real p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_BASIS_H

examples/simple/godot_headers/godot/color.h

@@ -0,0 +1,96 @@
+/*************************************************************************/
+/*  color.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_COLOR_H
+#define GODOT_COLOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_COLOR_SIZE 16
+
+#ifndef GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_COLOR_SIZE];
+} godot_color;
+#endif
+
+#include "gdnative.h"
+#include "string.h"
+
+void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a);
+void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b);
+
+godot_real godot_color_get_r(const godot_color *p_self);
+void godot_color_set_r(godot_color *p_self, const godot_real r);
+
+godot_real godot_color_get_g(const godot_color *p_self);
+void godot_color_set_g(godot_color *p_self, const godot_real g);
+
+godot_real godot_color_get_b(const godot_color *p_self);
+void godot_color_set_b(godot_color *p_self, const godot_real b);
+
+godot_real godot_color_get_a(const godot_color *p_self);
+void godot_color_set_a(godot_color *p_self, const godot_real a);
+
+godot_real godot_color_get_h(const godot_color *p_self);
+godot_real godot_color_get_s(const godot_color *p_self);
+godot_real godot_color_get_v(const godot_color *p_self);
+
+godot_string GDAPI godot_color_as_string(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_32(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_ARGB32(const godot_color *p_self);
+
+godot_real GDAPI godot_color_gray(const godot_color *p_self);
+
+godot_color GDAPI godot_color_inverted(const godot_color *p_self);
+
+godot_color GDAPI godot_color_contrasted(const godot_color *p_self);
+
+godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t);
+
+godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over);
+
+godot_string GDAPI godot_color_to_html(const godot_color *p_self, const godot_bool p_with_alpha);
+
+godot_bool GDAPI godot_color_operator_equal(const godot_color *p_self, const godot_color *p_b);
+
+godot_bool GDAPI godot_color_operator_less(const godot_color *p_self, const godot_color *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_COLOR_H

examples/simple/godot_headers/godot/dictionary.h

@@ -0,0 +1,89 @@
+/*************************************************************************/
+/*  dictionary.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_DICTIONARY_H
+#define GODOT_DICTIONARY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_DICTIONARY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_DICTIONARY_SIZE];
+} godot_dictionary;
+#endif
+
+#include "array.h"
+#include "gdnative.h"
+#include "variant.h"
+
+void GDAPI godot_dictionary_new(godot_dictionary *r_dest);
+void GDAPI godot_dictionary_new_copy(godot_dictionary *r_dest, const godot_dictionary *p_src);
+void GDAPI godot_dictionary_destroy(godot_dictionary *p_self);
+
+godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_self);
+
+godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_self);
+
+void GDAPI godot_dictionary_clear(godot_dictionary *p_self);
+
+godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_self, const godot_array *p_keys);
+
+void GDAPI godot_dictionary_erase(godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_int GDAPI godot_dictionary_hash(const godot_dictionary *p_self);
+
+godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_self);
+
+godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_self);
+
+godot_variant GDAPI godot_dictionary_get(const godot_dictionary *p_self, const godot_variant *p_key);
+void GDAPI godot_dictionary_set(godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value);
+
+godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_variant GDAPI *godot_dictionary_next(const godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_bool GDAPI godot_dictionary_operator_equal(const godot_dictionary *p_self, const godot_dictionary *p_b);
+
+godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_DICTIONARY_H

examples/simple/godot_headers/godot/gdnative.h

@@ -0,0 +1,302 @@
+/*************************************************************************/
+/*  gdnative.h                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_GDNATIVE_H
+#define GODOT_GDNATIVE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef GDAPI_BUILT_IN
+#define GDAPI_EXPORT
+#endif
+
+#ifdef _WIN32
+#if defined(GDAPI_EXPORT)
+#define GDCALLINGCONV
+#define GDAPI __declspec(dllexport) GDCALLINGCONV
+#else
+#define GDCALLINGCONV
+#define GDAPI __declspec(dllimport) GDCALLINGCONV
+#endif
+#elif defined(__APPLE__)
+#include "TargetConditionals.h"
+#if TARGET_OS_IPHONE
+#define GDCALLINGCONV
+#define GDAPI
+#elif TARGET_OS_MAC
+#define GDCALLINGCONV __attribute__((sysv_abi))
+#define GDAPI GDCALLINGCONV
+#endif
+#else
+#define GDCALLINGCONV __attribute__((sysv_abi))
+#define GDAPI GDCALLINGCONV
+#endif
+
+// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!!
+#ifdef _WIN32
+#define GDN_EXPORT __declspec(dllexport)
+#else
+#define GDN_EXPORT
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define GODOT_API_VERSION 1
+
+////// Error
+
+typedef enum {
+	GODOT_OK,
+	GODOT_FAILED, ///< Generic fail error
+	GODOT_ERR_UNAVAILABLE, ///< What is requested is unsupported/unavailable
+	GODOT_ERR_UNCONFIGURED, ///< The object being used hasnt been properly set up yet
+	GODOT_ERR_UNAUTHORIZED, ///< Missing credentials for requested resource
+	GODOT_ERR_PARAMETER_RANGE_ERROR, ///< Parameter given out of range (5)
+	GODOT_ERR_OUT_OF_MEMORY, ///< Out of memory
+	GODOT_ERR_FILE_NOT_FOUND,
+	GODOT_ERR_FILE_BAD_DRIVE,
+	GODOT_ERR_FILE_BAD_PATH,
+	GODOT_ERR_FILE_NO_PERMISSION, // (10)
+	GODOT_ERR_FILE_ALREADY_IN_USE,
+	GODOT_ERR_FILE_CANT_OPEN,
+	GODOT_ERR_FILE_CANT_WRITE,
+	GODOT_ERR_FILE_CANT_READ,
+	GODOT_ERR_FILE_UNRECOGNIZED, // (15)
+	GODOT_ERR_FILE_CORRUPT,
+	GODOT_ERR_FILE_MISSING_DEPENDENCIES,
+	GODOT_ERR_FILE_EOF,
+	GODOT_ERR_CANT_OPEN, ///< Can't open a resource/socket/file
+	GODOT_ERR_CANT_CREATE, // (20)
+	GODOT_ERR_QUERY_FAILED,
+	GODOT_ERR_ALREADY_IN_USE,
+	GODOT_ERR_LOCKED, ///< resource is locked
+	GODOT_ERR_TIMEOUT,
+	GODOT_ERR_CANT_CONNECT, // (25)
+	GODOT_ERR_CANT_RESOLVE,
+	GODOT_ERR_CONNECTION_ERROR,
+	GODOT_ERR_CANT_AQUIRE_RESOURCE,
+	GODOT_ERR_CANT_FORK,
+	GODOT_ERR_INVALID_DATA, ///< Data passed is invalid	(30)
+	GODOT_ERR_INVALID_PARAMETER, ///< Parameter passed is invalid
+	GODOT_ERR_ALREADY_EXISTS, ///< When adding, item already exists
+	GODOT_ERR_DOES_NOT_EXIST, ///< When retrieving/erasing, it item does not exist
+	GODOT_ERR_DATABASE_CANT_READ, ///< database is full
+	GODOT_ERR_DATABASE_CANT_WRITE, ///< database is full	(35)
+	GODOT_ERR_COMPILATION_FAILED,
+	GODOT_ERR_METHOD_NOT_FOUND,
+	GODOT_ERR_LINK_FAILED,
+	GODOT_ERR_SCRIPT_FAILED,
+	GODOT_ERR_CYCLIC_LINK, // (40)
+	GODOT_ERR_INVALID_DECLARATION,
+	GODOT_ERR_DUPLICATE_SYMBOL,
+	GODOT_ERR_PARSE_ERROR,
+	GODOT_ERR_BUSY,
+	GODOT_ERR_SKIP, // (45)
+	GODOT_ERR_HELP, ///< user requested help!!
+	GODOT_ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior.
+	GODOT_ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames
+	GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD, ///< shit happens, has never been used, though
+	GODOT_ERR_WTF = GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD ///< short version of the above
+} godot_error;
+
+////// bool
+
+typedef bool godot_bool;
+
+#define GODOT_TRUE 1
+#define GODOT_FALSE 0
+
+/////// int
+
+typedef int godot_int;
+
+/////// real
+
+typedef float godot_real;
+
+/////// Object (forward declared)
+typedef void godot_object;
+
+/////// Brute force forward declarations for the rest
+/*
+typedef struct godot_variant godot_variant;
+typedef struct godot_string godot_string;
+typedef struct godot_vector2 godot_vector2;
+typedef struct godot_rect2 godot_rect2;
+typedef struct godot_vector3 godot_vector3;
+typedef struct godot_transform2d godot_transform2d;
+typedef struct godot_plane godot_plane;
+typedef struct godot_quat godot_quat;
+typedef struct godot_rect3 godot_rect3;
+typedef struct godot_basis godot_basis;
+typedef struct godot_transform godot_transform;
+typedef struct godot_color godot_color;
+typedef struct godot_node_path godot_node_path;
+typedef struct godot_rid godot_rid;
+typedef struct godot_dictionary godot_dictionary;
+typedef struct godot_array godot_array;
+typedef struct godot_pool_byte_array godot_pool_byte_array;
+typedef struct godot_pool_int_array godot_pool_int_array;
+typedef struct godot_pool_real_array godot_pool_real_array;
+typedef struct godot_pool_string_array godot_pool_string_array;
+typedef struct godot_pool_vector2_array godot_pool_vector2_array;
+typedef struct godot_pool_vector3_array godot_pool_vector3_array;
+typedef struct godot_pool_color_array godot_pool_color_array;
+*/
+/////// String
+
+#include "string.h"
+
+////// Vector2
+
+#include "vector2.h"
+
+////// Rect2
+
+#include "rect2.h"
+
+////// Vector3
+
+#include "vector3.h"
+
+////// Transform2D
+
+#include "transform2d.h"
+
+/////// Plane
+
+#include "plane.h"
+
+/////// Quat
+
+#include "quat.h"
+
+/////// Rect3
+
+#include "rect3.h"
+
+/////// Basis
+
+#include "basis.h"
+
+/////// Transform
+
+#include "transform.h"
+
+/////// Color
+
+#include "color.h"
+
+/////// NodePath
+
+#include "node_path.h"
+
+/////// RID
+
+#include "rid.h"
+
+/////// Dictionary
+
+#include "dictionary.h"
+
+/////// Array
+
+#include "array.h"
+
+// single API file for Pool*Array
+#include "pool_arrays.h"
+
+void GDAPI godot_object_destroy(godot_object *p_o);
+
+////// Variant
+
+#include "variant.h"
+
+////// Singleton API
+
+godot_object GDAPI *godot_global_get_singleton(char *p_name); // result shouldn't be freed
+
+////// OS API
+
+void GDAPI *godot_get_stack_bottom(); //  returns stack bottom of the main thread
+
+////// MethodBind API
+
+typedef struct {
+	uint8_t _dont_touch_that[1]; // TODO
+} godot_method_bind;
+
+godot_method_bind GDAPI *godot_method_bind_get_method(const char *p_classname, const char *p_methodname);
+void GDAPI godot_method_bind_ptrcall(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret);
+godot_variant GDAPI godot_method_bind_call(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error);
+////// Script API
+
+typedef struct {
+	godot_bool in_editor;
+	uint64_t core_api_hash;
+	uint64_t editor_api_hash;
+	uint64_t no_api_hash;
+} godot_gdnative_init_options;
+
+typedef struct {
+	godot_bool in_editor;
+} godot_gdnative_terminate_options;
+
+// Calling convention?
+typedef godot_object *(*godot_class_constructor)();
+
+godot_class_constructor GDAPI godot_get_class_constructor(const char *p_classname);
+
+godot_dictionary GDAPI godot_get_global_constants();
+
+////// GDNative procedure types
+typedef void (*godot_gdnative_init_fn)(godot_gdnative_init_options *);
+typedef void (*godot_gdnative_terminate_fn)(godot_gdnative_terminate_options *);
+typedef godot_variant (*godot_gdnative_procedure_fn)(void *, godot_array *);
+
+////// System Functions
+
+//using these will help Godot track how much memory is in use in debug mode
+void GDAPI *godot_alloc(int p_bytes);
+void GDAPI *godot_realloc(void *p_ptr, int p_bytes);
+void GDAPI godot_free(void *p_ptr);
+
+//print using Godot's error handler list
+void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line);
+void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line);
+void GDAPI godot_print(const godot_string *p_message);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_C_H

examples/simple/godot_headers/godot/node_path.h

@@ -0,0 +1,77 @@
+/*************************************************************************/
+/*  node_path.h                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_NODE_PATH_H
+#define GODOT_NODE_PATH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_NODE_PATH_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_NODE_PATH_SIZE];
+} godot_node_path;
+#endif
+
+#include "gdnative.h"
+#include "string.h"
+
+void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from);
+void GDAPI godot_node_path_new_copy(godot_node_path *r_dest, const godot_node_path *p_src);
+void GDAPI godot_node_path_destroy(godot_node_path *p_self);
+
+godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_self);
+
+godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_self);
+
+godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_self);
+
+godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_self);
+
+godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_self, const godot_int p_idx);
+
+godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_self);
+
+godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_self);
+
+godot_bool GDAPI godot_node_path_operator_equal(const godot_node_path *p_self, const godot_node_path *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_NODE_PATH_H

examples/simple/godot_headers/godot/plane.h

@@ -0,0 +1,93 @@
+/*************************************************************************/
+/*  plane.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_PLANE_H
+#define GODOT_PLANE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_PLANE_SIZE 16
+
+#ifndef GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_PLANE_SIZE];
+} godot_plane;
+#endif
+
+#include "gdnative.h"
+#include "vector3.h"
+
+void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d);
+void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3);
+void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d);
+
+godot_string GDAPI godot_plane_as_string(const godot_plane *p_self);
+
+godot_plane GDAPI godot_plane_normalized(const godot_plane *p_self);
+
+godot_vector3 GDAPI godot_plane_center(const godot_plane *p_self);
+
+godot_vector3 GDAPI godot_plane_get_any_point(const godot_plane *p_self);
+
+godot_bool GDAPI godot_plane_is_point_over(const godot_plane *p_self, const godot_vector3 *p_point);
+
+godot_real GDAPI godot_plane_distance_to(const godot_plane *p_self, const godot_vector3 *p_point);
+
+godot_bool GDAPI godot_plane_has_point(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon);
+
+godot_vector3 GDAPI godot_plane_project(const godot_plane *p_self, const godot_vector3 *p_point);
+
+godot_bool GDAPI godot_plane_intersect_3(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c);
+
+godot_bool GDAPI godot_plane_intersects_ray(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir);
+
+godot_bool GDAPI godot_plane_intersects_segment(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end);
+
+godot_plane GDAPI godot_plane_operator_neg(const godot_plane *p_self);
+
+godot_bool GDAPI godot_plane_operator_equal(const godot_plane *p_self, const godot_plane *p_b);
+
+void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_normal);
+
+godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self);
+
+godot_real GDAPI godot_plane_get_d(const godot_plane *p_self);
+
+void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_PLANE_H

examples/simple/godot_headers/godot/pool_arrays.h

@@ -0,0 +1,316 @@
+/*************************************************************************/
+/*  pool_arrays.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_POOL_ARRAYS_H
+#define GODOT_POOL_ARRAYS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/////// PoolByteArray
+
+#define GODOT_POOL_BYTE_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_BYTE_ARRAY_SIZE];
+} godot_pool_byte_array;
+#endif
+
+/////// PoolIntArray
+
+#define GODOT_POOL_INT_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_INT_ARRAY_SIZE];
+} godot_pool_int_array;
+#endif
+
+/////// PoolRealArray
+
+#define GODOT_POOL_REAL_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_REAL_ARRAY_SIZE];
+} godot_pool_real_array;
+#endif
+
+/////// PoolStringArray
+
+#define GODOT_POOL_STRING_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_STRING_ARRAY_SIZE];
+} godot_pool_string_array;
+#endif
+
+/////// PoolVector2Array
+
+#define GODOT_POOL_VECTOR2_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_VECTOR2_ARRAY_SIZE];
+} godot_pool_vector2_array;
+#endif
+
+/////// PoolVector3Array
+
+#define GODOT_POOL_VECTOR3_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_VECTOR3_ARRAY_SIZE];
+} godot_pool_vector3_array;
+#endif
+
+/////// PoolColorArray
+
+#define GODOT_POOL_COLOR_ARRAY_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_COLOR_ARRAY_SIZE];
+} godot_pool_color_array;
+#endif
+
+#include "array.h"
+#include "color.h"
+#include "vector2.h"
+#include "vector3.h"
+
+#include "gdnative.h"
+
+// byte
+
+void GDAPI godot_pool_byte_array_new(godot_pool_byte_array *r_dest);
+void GDAPI godot_pool_byte_array_new_copy(godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src);
+void GDAPI godot_pool_byte_array_new_with_array(godot_pool_byte_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_byte_array_append(godot_pool_byte_array *p_self, const uint8_t p_data);
+
+void GDAPI godot_pool_byte_array_append_array(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array);
+
+godot_error GDAPI godot_pool_byte_array_insert(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
+
+void GDAPI godot_pool_byte_array_invert(godot_pool_byte_array *p_self);
+
+void GDAPI godot_pool_byte_array_push_back(godot_pool_byte_array *p_self, const uint8_t p_data);
+
+void GDAPI godot_pool_byte_array_remove(godot_pool_byte_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_byte_array_resize(godot_pool_byte_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_byte_array_set(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
+uint8_t GDAPI godot_pool_byte_array_get(const godot_pool_byte_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_byte_array_size(const godot_pool_byte_array *p_self);
+
+void GDAPI godot_pool_byte_array_destroy(godot_pool_byte_array *p_self);
+
+// int
+
+void GDAPI godot_pool_int_array_new(godot_pool_int_array *r_dest);
+void GDAPI godot_pool_int_array_new_copy(godot_pool_int_array *r_dest, const godot_pool_int_array *p_src);
+void GDAPI godot_pool_int_array_new_with_array(godot_pool_int_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_int_array_append(godot_pool_int_array *p_self, const godot_int p_data);
+
+void GDAPI godot_pool_int_array_append_array(godot_pool_int_array *p_self, const godot_pool_int_array *p_array);
+
+godot_error GDAPI godot_pool_int_array_insert(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
+
+void GDAPI godot_pool_int_array_invert(godot_pool_int_array *p_self);
+
+void GDAPI godot_pool_int_array_push_back(godot_pool_int_array *p_self, const godot_int p_data);
+
+void GDAPI godot_pool_int_array_remove(godot_pool_int_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_int_array_resize(godot_pool_int_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_int_array_set(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
+godot_int GDAPI godot_pool_int_array_get(const godot_pool_int_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_int_array_size(const godot_pool_int_array *p_self);
+
+void GDAPI godot_pool_int_array_destroy(godot_pool_int_array *p_self);
+
+// real
+
+void GDAPI godot_pool_real_array_new(godot_pool_real_array *r_dest);
+void GDAPI godot_pool_real_array_new_copy(godot_pool_real_array *r_dest, const godot_pool_real_array *p_src);
+void GDAPI godot_pool_real_array_new_with_array(godot_pool_real_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_real_array_append(godot_pool_real_array *p_self, const godot_real p_data);
+
+void GDAPI godot_pool_real_array_append_array(godot_pool_real_array *p_self, const godot_pool_real_array *p_array);
+
+godot_error GDAPI godot_pool_real_array_insert(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
+
+void GDAPI godot_pool_real_array_invert(godot_pool_real_array *p_self);
+
+void GDAPI godot_pool_real_array_push_back(godot_pool_real_array *p_self, const godot_real p_data);
+
+void GDAPI godot_pool_real_array_remove(godot_pool_real_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_real_array_resize(godot_pool_real_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_real_array_set(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
+godot_real GDAPI godot_pool_real_array_get(const godot_pool_real_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_real_array_size(const godot_pool_real_array *p_self);
+
+void GDAPI godot_pool_real_array_destroy(godot_pool_real_array *p_self);
+
+// string
+
+void GDAPI godot_pool_string_array_new(godot_pool_string_array *r_dest);
+void GDAPI godot_pool_string_array_new_copy(godot_pool_string_array *r_dest, const godot_pool_string_array *p_src);
+void GDAPI godot_pool_string_array_new_with_array(godot_pool_string_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_string_array_append(godot_pool_string_array *p_self, const godot_string *p_data);
+
+void GDAPI godot_pool_string_array_append_array(godot_pool_string_array *p_self, const godot_pool_string_array *p_array);
+
+godot_error GDAPI godot_pool_string_array_insert(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
+
+void GDAPI godot_pool_string_array_invert(godot_pool_string_array *p_self);
+
+void GDAPI godot_pool_string_array_push_back(godot_pool_string_array *p_self, const godot_string *p_data);
+
+void GDAPI godot_pool_string_array_remove(godot_pool_string_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_string_array_resize(godot_pool_string_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_string_array_set(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
+godot_string GDAPI godot_pool_string_array_get(const godot_pool_string_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_string_array_size(const godot_pool_string_array *p_self);
+
+void GDAPI godot_pool_string_array_destroy(godot_pool_string_array *p_self);
+
+// vector2
+
+void GDAPI godot_pool_vector2_array_new(godot_pool_vector2_array *r_dest);
+void GDAPI godot_pool_vector2_array_new_copy(godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src);
+void GDAPI godot_pool_vector2_array_new_with_array(godot_pool_vector2_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_vector2_array_append(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
+
+void GDAPI godot_pool_vector2_array_append_array(godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array);
+
+godot_error GDAPI godot_pool_vector2_array_insert(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
+
+void GDAPI godot_pool_vector2_array_invert(godot_pool_vector2_array *p_self);
+
+void GDAPI godot_pool_vector2_array_push_back(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
+
+void GDAPI godot_pool_vector2_array_remove(godot_pool_vector2_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_vector2_array_resize(godot_pool_vector2_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_vector2_array_set(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
+godot_vector2 GDAPI godot_pool_vector2_array_get(const godot_pool_vector2_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_vector2_array_size(const godot_pool_vector2_array *p_self);
+
+void GDAPI godot_pool_vector2_array_destroy(godot_pool_vector2_array *p_self);
+
+// vector3
+
+void GDAPI godot_pool_vector3_array_new(godot_pool_vector3_array *r_dest);
+void GDAPI godot_pool_vector3_array_new_copy(godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src);
+void GDAPI godot_pool_vector3_array_new_with_array(godot_pool_vector3_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_vector3_array_append(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
+
+void GDAPI godot_pool_vector3_array_append_array(godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array);
+
+godot_error GDAPI godot_pool_vector3_array_insert(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
+
+void GDAPI godot_pool_vector3_array_invert(godot_pool_vector3_array *p_self);
+
+void GDAPI godot_pool_vector3_array_push_back(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
+
+void GDAPI godot_pool_vector3_array_remove(godot_pool_vector3_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_vector3_array_resize(godot_pool_vector3_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_vector3_array_set(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
+godot_vector3 GDAPI godot_pool_vector3_array_get(const godot_pool_vector3_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_vector3_array_size(const godot_pool_vector3_array *p_self);
+
+void GDAPI godot_pool_vector3_array_destroy(godot_pool_vector3_array *p_self);
+
+// color
+
+void GDAPI godot_pool_color_array_new(godot_pool_color_array *r_dest);
+void GDAPI godot_pool_color_array_new_copy(godot_pool_color_array *r_dest, const godot_pool_color_array *p_src);
+void GDAPI godot_pool_color_array_new_with_array(godot_pool_color_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_color_array_append(godot_pool_color_array *p_self, const godot_color *p_data);
+
+void GDAPI godot_pool_color_array_append_array(godot_pool_color_array *p_self, const godot_pool_color_array *p_array);
+
+godot_error GDAPI godot_pool_color_array_insert(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
+
+void GDAPI godot_pool_color_array_invert(godot_pool_color_array *p_self);
+
+void GDAPI godot_pool_color_array_push_back(godot_pool_color_array *p_self, const godot_color *p_data);
+
+void GDAPI godot_pool_color_array_remove(godot_pool_color_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_color_array_resize(godot_pool_color_array *p_self, const godot_int p_size);
+
+void GDAPI godot_pool_color_array_set(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
+godot_color GDAPI godot_pool_color_array_get(const godot_pool_color_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_color_array_size(const godot_pool_color_array *p_self);
+
+void GDAPI godot_pool_color_array_destroy(godot_pool_color_array *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_POOL_ARRAYS_H

examples/simple/godot_headers/godot/quat.h

@@ -0,0 +1,104 @@
+/*************************************************************************/
+/*  quat.h                                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_QUAT_H
+#define GODOT_QUAT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_QUAT_SIZE 16
+
+#ifndef GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_QUAT_SIZE];
+} godot_quat;
+#endif
+
+#include "gdnative.h"
+#include "vector3.h"
+
+void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w);
+void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle);
+
+godot_real GDAPI godot_quat_get_x(const godot_quat *p_self);
+void GDAPI godot_quat_set_x(godot_quat *p_self, const godot_real val);
+
+godot_real GDAPI godot_quat_get_y(const godot_quat *p_self);
+void GDAPI godot_quat_set_y(godot_quat *p_self, const godot_real val);
+
+godot_real GDAPI godot_quat_get_z(const godot_quat *p_self);
+void GDAPI godot_quat_set_z(godot_quat *p_self, const godot_real val);
+
+godot_real GDAPI godot_quat_get_w(const godot_quat *p_self);
+void GDAPI godot_quat_set_w(godot_quat *p_self, const godot_real val);
+
+godot_string GDAPI godot_quat_as_string(const godot_quat *p_self);
+
+godot_real GDAPI godot_quat_length(const godot_quat *p_self);
+
+godot_real GDAPI godot_quat_length_squared(const godot_quat *p_self);
+
+godot_quat GDAPI godot_quat_normalized(const godot_quat *p_self);
+
+godot_bool GDAPI godot_quat_is_normalized(const godot_quat *p_self);
+
+godot_quat GDAPI godot_quat_inverse(const godot_quat *p_self);
+
+godot_real GDAPI godot_quat_dot(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_vector3 GDAPI godot_quat_xform(const godot_quat *p_self, const godot_vector3 *p_v);
+
+godot_quat GDAPI godot_quat_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
+
+godot_quat GDAPI godot_quat_slerpni(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
+
+godot_quat GDAPI godot_quat_cubic_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t);
+
+godot_quat GDAPI godot_quat_operator_multiply(const godot_quat *p_self, const godot_real p_b);
+
+godot_quat GDAPI godot_quat_operator_add(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_quat GDAPI godot_quat_operator_substract(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_quat GDAPI godot_quat_operator_divide(const godot_quat *p_self, const godot_real p_b);
+
+godot_bool GDAPI godot_quat_operator_equal(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_quat GDAPI godot_quat_operator_neg(const godot_quat *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_QUAT_H

examples/simple/godot_headers/godot/rect2.h

@@ -0,0 +1,86 @@
+/*************************************************************************/
+/*  rect2.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_RECT2_H
+#define GODOT_RECT2_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#ifndef GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED
+typedef struct godot_rect2 {
+	uint8_t _dont_touch_that[16];
+} godot_rect2;
+#endif
+
+#include "gdnative.h"
+#include "vector2.h"
+
+void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
+void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height);
+
+godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self);
+
+godot_real GDAPI godot_rect2_get_area(const godot_rect2 *p_self);
+
+godot_bool GDAPI godot_rect2_intersects(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_bool GDAPI godot_rect2_encloses(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_bool GDAPI godot_rect2_has_no_area(const godot_rect2 *p_self);
+
+godot_rect2 GDAPI godot_rect2_clip(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_rect2 GDAPI godot_rect2_merge(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_bool GDAPI godot_rect2_has_point(const godot_rect2 *p_self, const godot_vector2 *p_point);
+
+godot_rect2 GDAPI godot_rect2_grow(const godot_rect2 *p_self, const godot_real p_by);
+
+godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vector2 *p_to);
+
+godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_vector2 GDAPI godot_rect2_get_position(const godot_rect2 *p_self);
+
+godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self);
+
+void GDAPI godot_rect2_set_position(godot_rect2 *p_self, const godot_vector2 *p_pos);
+
+void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_RECT2_H

examples/simple/godot_headers/godot/rect3.h

@@ -0,0 +1,108 @@
+/*************************************************************************/
+/*  rect3.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_RECT3_H
+#define GODOT_RECT3_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_RECT3_SIZE 24
+
+#ifndef GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_RECT3_SIZE];
+} godot_rect3;
+#endif
+
+#include "gdnative.h"
+#include "plane.h"
+#include "vector3.h"
+
+void GDAPI godot_rect3_new(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size);
+
+godot_vector3 GDAPI godot_rect3_get_position(const godot_rect3 *p_self);
+void GDAPI godot_rect3_set_position(const godot_rect3 *p_self, const godot_vector3 *p_v);
+
+godot_vector3 GDAPI godot_rect3_get_size(const godot_rect3 *p_self);
+void GDAPI godot_rect3_set_size(const godot_rect3 *p_self, const godot_vector3 *p_v);
+
+godot_string GDAPI godot_rect3_as_string(const godot_rect3 *p_self);
+
+godot_real GDAPI godot_rect3_get_area(const godot_rect3 *p_self);
+
+godot_bool GDAPI godot_rect3_has_no_area(const godot_rect3 *p_self);
+
+godot_bool GDAPI godot_rect3_has_no_surface(const godot_rect3 *p_self);
+
+godot_bool GDAPI godot_rect3_intersects(const godot_rect3 *p_self, const godot_rect3 *p_with);
+
+godot_bool GDAPI godot_rect3_encloses(const godot_rect3 *p_self, const godot_rect3 *p_with);
+
+godot_rect3 GDAPI godot_rect3_merge(const godot_rect3 *p_self, const godot_rect3 *p_with);
+
+godot_rect3 GDAPI godot_rect3_intersection(const godot_rect3 *p_self, const godot_rect3 *p_with);
+
+godot_bool GDAPI godot_rect3_intersects_plane(const godot_rect3 *p_self, const godot_plane *p_plane);
+
+godot_bool GDAPI godot_rect3_intersects_segment(const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to);
+
+godot_bool GDAPI godot_rect3_has_point(const godot_rect3 *p_self, const godot_vector3 *p_point);
+
+godot_vector3 GDAPI godot_rect3_get_support(const godot_rect3 *p_self, const godot_vector3 *p_dir);
+
+godot_vector3 GDAPI godot_rect3_get_longest_axis(const godot_rect3 *p_self);
+
+godot_int GDAPI godot_rect3_get_longest_axis_index(const godot_rect3 *p_self);
+
+godot_real GDAPI godot_rect3_get_longest_axis_size(const godot_rect3 *p_self);
+
+godot_vector3 GDAPI godot_rect3_get_shortest_axis(const godot_rect3 *p_self);
+
+godot_int GDAPI godot_rect3_get_shortest_axis_index(const godot_rect3 *p_self);
+
+godot_real GDAPI godot_rect3_get_shortest_axis_size(const godot_rect3 *p_self);
+
+godot_rect3 GDAPI godot_rect3_expand(const godot_rect3 *p_self, const godot_vector3 *p_to_point);
+
+godot_rect3 GDAPI godot_rect3_grow(const godot_rect3 *p_self, const godot_real p_by);
+
+godot_vector3 GDAPI godot_rect3_get_endpoint(const godot_rect3 *p_self, const godot_int p_idx);
+
+godot_bool GDAPI godot_rect3_operator_equal(const godot_rect3 *p_self, const godot_rect3 *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_RECT3_H

examples/simple/godot_headers/godot/rid.h

@@ -0,0 +1,64 @@
+/*************************************************************************/
+/*  rid.h                                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_RID_H
+#define GODOT_RID_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_RID_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_RID_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_RID_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_RID_SIZE];
+} godot_rid;
+#endif
+
+#include "gdnative.h"
+
+void GDAPI godot_rid_new(godot_rid *r_dest);
+
+godot_int GDAPI godot_rid_get_id(const godot_rid *p_self);
+
+void GDAPI godot_rid_new_with_resource(godot_rid *r_dest, const godot_object *p_from);
+
+godot_bool GDAPI godot_rid_operator_equal(const godot_rid *p_self, const godot_rid *p_b);
+
+godot_bool GDAPI godot_rid_operator_less(const godot_rid *p_self, const godot_rid *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_RID_H

examples/simple/godot_headers/godot/string.h

@@ -0,0 +1,76 @@
+/*************************************************************************/
+/*  string.h                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_STRING_H
+#define GODOT_STRING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <wchar.h>
+
+#define GODOT_STRING_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_STRING_SIZE];
+} godot_string;
+#endif
+
+#include "gdnative.h"
+
+void GDAPI godot_string_new(godot_string *r_dest);
+void GDAPI godot_string_new_copy(godot_string *r_dest, const godot_string *p_src);
+void GDAPI godot_string_new_data(godot_string *r_dest, const char *p_contents, const int p_size);
+void GDAPI godot_string_new_unicode_data(godot_string *r_dest, const wchar_t *p_contents, const int p_size);
+
+void GDAPI godot_string_get_data(const godot_string *p_self, char *p_dest, int *p_size);
+
+wchar_t GDAPI *godot_string_operator_index(godot_string *p_self, const godot_int p_idx);
+const char GDAPI *godot_string_c_str(const godot_string *p_self);
+const wchar_t GDAPI *godot_string_unicode_str(const godot_string *p_self);
+
+godot_bool GDAPI godot_string_operator_equal(const godot_string *p_self, const godot_string *p_b);
+godot_bool GDAPI godot_string_operator_less(const godot_string *p_self, const godot_string *p_b);
+godot_string GDAPI godot_string_operator_plus(const godot_string *p_self, const godot_string *p_b);
+
+// @Incomplete
+// hmm, I guess exposing the whole API doesn't make much sense
+// since the language used in the library has its own string funcs
+
+void GDAPI godot_string_destroy(godot_string *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_STRING_H

examples/simple/godot_headers/godot/transform.h

@@ -0,0 +1,100 @@
+/*************************************************************************/
+/*  transform.h                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_TRANSFORM_H
+#define GODOT_TRANSFORM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_TRANSFORM_SIZE 48
+
+#ifndef GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_TRANSFORM_SIZE];
+} godot_transform;
+#endif
+
+#include "basis.h"
+#include "gdnative.h"
+#include "variant.h"
+#include "vector3.h"
+
+void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin);
+void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin);
+
+godot_basis GDAPI godot_transform_get_basis(const godot_transform *p_self);
+void GDAPI godot_transform_set_basis(godot_transform *p_self, godot_basis *p_v);
+
+godot_vector3 GDAPI godot_transform_get_origin(const godot_transform *p_self);
+void GDAPI godot_transform_set_origin(godot_transform *p_self, godot_vector3 *p_v);
+
+godot_string GDAPI godot_transform_as_string(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_inverse(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_affine_inverse(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_orthonormalized(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_rotated(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+
+godot_transform GDAPI godot_transform_scaled(const godot_transform *p_self, const godot_vector3 *p_scale);
+
+godot_transform GDAPI godot_transform_translated(const godot_transform *p_self, const godot_vector3 *p_ofs);
+
+godot_transform GDAPI godot_transform_looking_at(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up);
+
+godot_plane GDAPI godot_transform_xform_plane(const godot_transform *p_self, const godot_plane *p_v);
+
+godot_plane GDAPI godot_transform_xform_inv_plane(const godot_transform *p_self, const godot_plane *p_v);
+
+void GDAPI godot_transform_new_identity(godot_transform *r_dest);
+
+godot_bool GDAPI godot_transform_operator_equal(const godot_transform *p_self, const godot_transform *p_b);
+
+godot_transform GDAPI godot_transform_operator_multiply(const godot_transform *p_self, const godot_transform *p_b);
+
+godot_vector3 GDAPI godot_transform_xform_vector3(const godot_transform *p_self, const godot_vector3 *p_v);
+
+godot_vector3 GDAPI godot_transform_xform_inv_vector3(const godot_transform *p_self, const godot_vector3 *p_v);
+
+godot_rect3 GDAPI godot_transform_xform_rect3(const godot_transform *p_self, const godot_rect3 *p_v);
+
+godot_rect3 GDAPI godot_transform_xform_inv_rect3(const godot_transform *p_self, const godot_rect3 *p_v);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_TRANSFORM_H

examples/simple/godot_headers/godot/transform2d.h

@@ -0,0 +1,99 @@
+/*************************************************************************/
+/*  transform2d.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_TRANSFORM2D_H
+#define GODOT_TRANSFORM2D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_TRANSFORM2D_SIZE 24
+
+#ifndef GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_TRANSFORM2D_SIZE];
+} godot_transform2d;
+#endif
+
+#include "gdnative.h"
+#include "variant.h"
+#include "vector2.h"
+
+void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos);
+void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin);
+
+godot_string GDAPI godot_transform2d_as_string(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_affine_inverse(const godot_transform2d *p_self);
+
+godot_real GDAPI godot_transform2d_get_rotation(const godot_transform2d *p_self);
+
+godot_vector2 GDAPI godot_transform2d_get_origin(const godot_transform2d *p_self);
+
+godot_vector2 GDAPI godot_transform2d_get_scale(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_orthonormalized(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_rotated(const godot_transform2d *p_self, const godot_real p_phi);
+
+godot_transform2d GDAPI godot_transform2d_scaled(const godot_transform2d *p_self, const godot_vector2 *p_scale);
+
+godot_transform2d GDAPI godot_transform2d_translated(const godot_transform2d *p_self, const godot_vector2 *p_offset);
+
+godot_vector2 GDAPI godot_transform2d_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_vector2 GDAPI godot_transform2d_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_vector2 GDAPI godot_transform2d_basis_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_vector2 GDAPI godot_transform2d_basis_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_transform2d GDAPI godot_transform2d_interpolate_with(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c);
+
+godot_bool GDAPI godot_transform2d_operator_equal(const godot_transform2d *p_self, const godot_transform2d *p_b);
+
+godot_transform2d GDAPI godot_transform2d_operator_multiply(const godot_transform2d *p_self, const godot_transform2d *p_b);
+
+void GDAPI godot_transform2d_new_identity(godot_transform2d *r_dest);
+
+godot_rect2 GDAPI godot_transform2d_xform_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v);
+
+godot_rect2 GDAPI godot_transform2d_xform_inv_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_TRANSFORM2D_H

examples/simple/godot_headers/godot/variant.h

@@ -0,0 +1,201 @@
+/*************************************************************************/
+/*  variant.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_VARIANT_H
+#define GODOT_VARIANT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_VARIANT_SIZE 24
+
+#ifndef GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VARIANT_SIZE];
+} godot_variant;
+#endif
+
+typedef enum godot_variant_type {
+	GODOT_VARIANT_TYPE_NIL,
+
+	// atomic types
+	GODOT_VARIANT_TYPE_BOOL,
+	GODOT_VARIANT_TYPE_INT,
+	GODOT_VARIANT_TYPE_REAL,
+	GODOT_VARIANT_TYPE_STRING,
+
+	// math types
+
+	GODOT_VARIANT_TYPE_VECTOR2, // 5
+	GODOT_VARIANT_TYPE_RECT2,
+	GODOT_VARIANT_TYPE_VECTOR3,
+	GODOT_VARIANT_TYPE_TRANSFORM2D,
+	GODOT_VARIANT_TYPE_PLANE,
+	GODOT_VARIANT_TYPE_QUAT, // 10
+	GODOT_VARIANT_TYPE_RECT3,
+	GODOT_VARIANT_TYPE_BASIS,
+	GODOT_VARIANT_TYPE_TRANSFORM,
+
+	// misc types
+	GODOT_VARIANT_TYPE_COLOR,
+	GODOT_VARIANT_TYPE_NODE_PATH, // 15
+	GODOT_VARIANT_TYPE_RID,
+	GODOT_VARIANT_TYPE_OBJECT,
+	GODOT_VARIANT_TYPE_DICTIONARY,
+	GODOT_VARIANT_TYPE_ARRAY, // 20
+
+	// arrays
+	GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_INT_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_REAL_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_STRING_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY, // 25
+	GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY,
+} godot_variant_type;
+
+typedef enum godot_variant_call_error_error {
+	GODOT_CALL_ERROR_CALL_OK,
+	GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD,
+	GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT,
+	GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS,
+	GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS,
+	GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL,
+} godot_variant_call_error_error;
+
+typedef struct godot_variant_call_error {
+	godot_variant_call_error_error error;
+	int argument;
+	godot_variant_type expected;
+} godot_variant_call_error;
+
+#include "array.h"
+#include "basis.h"
+#include "color.h"
+#include "dictionary.h"
+#include "node_path.h"
+#include "plane.h"
+#include "pool_arrays.h"
+#include "quat.h"
+#include "rect2.h"
+#include "rect3.h"
+#include "rid.h"
+#include "string.h"
+#include "transform.h"
+#include "transform2d.h"
+#include "variant.h"
+#include "vector2.h"
+#include "vector3.h"
+
+#include "gdnative.h"
+
+godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v);
+
+void GDAPI godot_variant_new_copy(godot_variant *r_dest, const godot_variant *p_src);
+
+void GDAPI godot_variant_new_nil(godot_variant *r_dest);
+
+void GDAPI godot_variant_new_bool(godot_variant *p_v, const godot_bool p_b);
+void GDAPI godot_variant_new_uint(godot_variant *r_dest, const uint64_t p_i);
+void GDAPI godot_variant_new_int(godot_variant *r_dest, const int64_t p_i);
+void GDAPI godot_variant_new_real(godot_variant *r_dest, const double p_r);
+void GDAPI godot_variant_new_string(godot_variant *r_dest, const godot_string *p_s);
+void GDAPI godot_variant_new_vector2(godot_variant *r_dest, const godot_vector2 *p_v2);
+void GDAPI godot_variant_new_rect2(godot_variant *r_dest, const godot_rect2 *p_rect2);
+void GDAPI godot_variant_new_vector3(godot_variant *r_dest, const godot_vector3 *p_v3);
+void GDAPI godot_variant_new_transform2d(godot_variant *r_dest, const godot_transform2d *p_t2d);
+void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_plane);
+void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat);
+void GDAPI godot_variant_new_rect3(godot_variant *r_dest, const godot_rect3 *p_rect3);
+void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis);
+void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans);
+void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color);
+void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np);
+void GDAPI godot_variant_new_rid(godot_variant *r_dest, const godot_rid *p_rid);
+void GDAPI godot_variant_new_object(godot_variant *r_dest, const godot_object *p_obj);
+void GDAPI godot_variant_new_dictionary(godot_variant *r_dest, const godot_dictionary *p_dict);
+void GDAPI godot_variant_new_array(godot_variant *r_dest, const godot_array *p_arr);
+void GDAPI godot_variant_new_pool_byte_array(godot_variant *r_dest, const godot_pool_byte_array *p_pba);
+void GDAPI godot_variant_new_pool_int_array(godot_variant *r_dest, const godot_pool_int_array *p_pia);
+void GDAPI godot_variant_new_pool_real_array(godot_variant *r_dest, const godot_pool_real_array *p_pra);
+void GDAPI godot_variant_new_pool_string_array(godot_variant *r_dest, const godot_pool_string_array *p_psa);
+void GDAPI godot_variant_new_pool_vector2_array(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a);
+void GDAPI godot_variant_new_pool_vector3_array(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a);
+void GDAPI godot_variant_new_pool_color_array(godot_variant *r_dest, const godot_pool_color_array *p_pca);
+
+godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_self);
+uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_self);
+int64_t GDAPI godot_variant_as_int(const godot_variant *p_self);
+double GDAPI godot_variant_as_real(const godot_variant *p_self);
+godot_string GDAPI godot_variant_as_string(const godot_variant *p_self);
+godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_self);
+godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_self);
+godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_self);
+godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_self);
+godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self);
+godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self);
+godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_self);
+godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self);
+godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self);
+godot_color GDAPI godot_variant_as_color(const godot_variant *p_self);
+godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self);
+godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_self);
+godot_object GDAPI *godot_variant_as_object(const godot_variant *p_self);
+godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_self);
+godot_array GDAPI godot_variant_as_array(const godot_variant *p_self);
+godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_self);
+godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_self);
+godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_self);
+godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_self);
+godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_self);
+godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_self);
+godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_self);
+
+godot_variant GDAPI godot_variant_call(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error);
+
+godot_bool GDAPI godot_variant_has_method(const godot_variant *p_self, const godot_string *p_method);
+
+godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_self, const godot_variant *p_other);
+godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_self, const godot_variant *p_other);
+
+godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_self, const godot_variant *p_other);
+
+godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_self, godot_bool *r_valid);
+
+void GDAPI godot_variant_destroy(godot_variant *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

examples/simple/godot_headers/godot/vector2.h

@@ -0,0 +1,128 @@
+/*************************************************************************/
+/*  vector2.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_VECTOR2_H
+#define GODOT_VECTOR2_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_VECTOR2_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VECTOR2_SIZE];
+} godot_vector2;
+#endif
+
+#include "gdnative.h"
+
+void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y);
+
+godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_length(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_self);
+
+godot_bool GDAPI godot_vector2_is_normalized(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t);
+
+godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t);
+
+godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_self, const godot_real p_phi);
+
+godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_self, const godot_vector2 *p_by);
+
+godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_self, const godot_vector2 *p_with);
+
+godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_self, const godot_vector2 *p_n);
+
+godot_vector2 GDAPI godot_vector2_bounce(const godot_vector2 *p_self, const godot_vector2 *p_n);
+
+godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_self, const godot_vector2 *p_n);
+
+godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_self, const godot_real p_length);
+
+godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_substract(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_self, const godot_real p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_self, const godot_real p_b);
+
+godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_neg(const godot_vector2 *p_self);
+
+void GDAPI godot_vector2_set_x(godot_vector2 *p_self, const godot_real p_x);
+
+void GDAPI godot_vector2_set_y(godot_vector2 *p_self, const godot_real p_y);
+
+godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_VECTOR2_H

examples/simple/godot_headers/godot/vector3.h

@@ -0,0 +1,135 @@
+/*************************************************************************/
+/*  vector3.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_VECTOR3_H
+#define GODOT_VECTOR3_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_VECTOR3_SIZE 12
+
+#ifndef GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VECTOR3_SIZE];
+} godot_vector3;
+#endif
+
+#include "basis.h"
+#include "gdnative.h"
+
+typedef enum {
+	GODOT_VECTOR3_AXIS_X,
+	GODOT_VECTOR3_AXIS_Y,
+	GODOT_VECTOR3_AXIS_Z,
+} godot_vector3_axis;
+
+void GDAPI godot_vector3_new(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z);
+
+godot_string GDAPI godot_vector3_as_string(const godot_vector3 *p_self);
+
+godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_self);
+
+godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_self);
+
+godot_real GDAPI godot_vector3_length(const godot_vector3 *p_self);
+
+godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_self);
+
+godot_bool GDAPI godot_vector3_is_normalized(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const godot_vector3 *p_by);
+
+godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+
+godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t);
+
+godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t);
+
+godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_self);
+
+godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_self, const godot_vector3 *p_to);
+
+godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_self, const godot_vector3 *p_n);
+
+godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_self, const godot_vector3 *p_n);
+
+godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_self, const godot_vector3 *p_n);
+
+godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_substract(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_self, const godot_real p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_self, const godot_real p_b);
+
+godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_neg(const godot_vector3 *p_self);
+
+void GDAPI godot_vector3_set_axis(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val);
+
+godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_self, const godot_vector3_axis p_axis);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_VECTOR3_H

examples/simple/godot_headers/godot_nativescript.h

@@ -0,0 +1,228 @@
+/*************************************************************************/
+/*  godot.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef GODOT_NATIVESCRIPT_H
+#define GODOT_NATIVESCRIPT_H
+
+#include <godot/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef GDAPI_BUILT_IN
+#define GDAPI_EXPORT
+#endif
+
+#ifdef _WIN32
+#if defined(GDAPI_EXPORT)
+#define GDCALLINGCONV
+#define GDAPI __declspec(dllexport) GDCALLINGCONV
+#else
+#define GDCALLINGCONV
+#define GDAPI __declspec(dllimport) GDCALLINGCONV
+#endif
+#elif defined(__APPLE__)
+#include "TargetConditionals.h"
+#if TARGET_OS_IPHONE
+#define GDCALLINGCONV
+#define GDAPI
+#elif TARGET_OS_MAC
+#define GDCALLINGCONV __attribute__((sysv_abi))
+#define GDAPI GDCALLINGCONV
+#endif
+#else
+#define GDCALLINGCONV __attribute__((sysv_abi))
+#define GDAPI GDCALLINGCONV
+#endif
+
+// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!!
+#ifdef _WIN32
+#define GDN_EXPORT __declspec(dllexport)
+#else
+#define GDN_EXPORT
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef enum {
+	GODOT_METHOD_RPC_MODE_DISABLED,
+	GODOT_METHOD_RPC_MODE_REMOTE,
+	GODOT_METHOD_RPC_MODE_SYNC,
+	GODOT_METHOD_RPC_MODE_MASTER,
+	GODOT_METHOD_RPC_MODE_SLAVE,
+} godot_method_rpc_mode;
+
+typedef enum {
+	GODOT_PROPERTY_HINT_NONE, ///< no hint provided.
+	GODOT_PROPERTY_HINT_RANGE, ///< hint_text = "min,max,step,slider; //slider is optional"
+	GODOT_PROPERTY_HINT_EXP_RANGE, ///< hint_text = "min,max,step", exponential edit
+	GODOT_PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc"
+	GODOT_PROPERTY_HINT_EXP_EASING, /// exponential easing funciton (Math::ease)
+	GODOT_PROPERTY_HINT_LENGTH, ///< hint_text= "length" (as integer)
+	GODOT_PROPERTY_HINT_SPRITE_FRAME,
+	GODOT_PROPERTY_HINT_KEY_ACCEL, ///< hint_text= "length" (as integer)
+	GODOT_PROPERTY_HINT_FLAGS, ///< hint_text= "flag1,flag2,etc" (as bit flags)
+	GODOT_PROPERTY_HINT_LAYERS_2D_RENDER,
+	GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS,
+	GODOT_PROPERTY_HINT_LAYERS_3D_RENDER,
+	GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS,
+	GODOT_PROPERTY_HINT_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+	GODOT_PROPERTY_HINT_DIR, ///< a directort path must be passed
+	GODOT_PROPERTY_HINT_GLOBAL_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+	GODOT_PROPERTY_HINT_GLOBAL_DIR, ///< a directort path must be passed
+	GODOT_PROPERTY_HINT_RESOURCE_TYPE, ///< a resource object type
+	GODOT_PROPERTY_HINT_MULTILINE_TEXT, ///< used for string properties that can contain multiple lines
+	GODOT_PROPERTY_HINT_COLOR_NO_ALPHA, ///< used for ignoring alpha component when editing a color
+	GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY,
+	GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS,
+	GODOT_PROPERTY_HINT_OBJECT_ID,
+	GODOT_PROPERTY_HINT_TYPE_STRING, ///< a type string, the hint is the base type to choose
+	GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE, ///< so something else can provide this (used in scripts)
+	GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE, ///< a method of a type
+	GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE, ///< a method of a base type
+	GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE, ///< a method of an instance
+	GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT, ///< a method of a script & base
+	GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE, ///< a property of a type
+	GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE, ///< a property of a base type
+	GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE, ///< a property of an instance
+	GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT, ///< a property of a script & base
+	GODOT_PROPERTY_HINT_MAX,
+} godot_property_hint;
+
+typedef enum {
+
+	GODOT_PROPERTY_USAGE_STORAGE = 1,
+	GODOT_PROPERTY_USAGE_EDITOR = 2,
+	GODOT_PROPERTY_USAGE_NETWORK = 4,
+	GODOT_PROPERTY_USAGE_EDITOR_HELPER = 8,
+	GODOT_PROPERTY_USAGE_CHECKABLE = 16, //used for editing global variables
+	GODOT_PROPERTY_USAGE_CHECKED = 32, //used for editing global variables
+	GODOT_PROPERTY_USAGE_INTERNATIONALIZED = 64, //hint for internationalized strings
+	GODOT_PROPERTY_USAGE_GROUP = 128, //used for grouping props in the editor
+	GODOT_PROPERTY_USAGE_CATEGORY = 256,
+	GODOT_PROPERTY_USAGE_STORE_IF_NONZERO = 512, //only store if nonzero
+	GODOT_PROPERTY_USAGE_STORE_IF_NONONE = 1024, //only store if false
+	GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE = 2048,
+	GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED = 4096,
+	GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE = 8192,
+	GODOT_PROPERTY_USAGE_STORE_IF_NULL = 16384,
+	GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER = 32768,
+	GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 65536,
+
+	GODOT_PROPERTY_USAGE_DEFAULT = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK,
+	GODOT_PROPERTY_USAGE_DEFAULT_INTL = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK | GODOT_PROPERTY_USAGE_INTERNATIONALIZED,
+	GODOT_PROPERTY_USAGE_NOEDITOR = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_NETWORK,
+} godot_property_usage_flags;
+
+typedef struct {
+	godot_method_rpc_mode rset_type;
+
+	godot_int type;
+	godot_property_hint hint;
+	godot_string hint_string;
+	godot_property_usage_flags usage;
+	godot_variant default_value;
+} godot_property_attributes;
+
+typedef struct {
+	// instance pointer, method_data - return user data
+	GDCALLINGCONV void *(*create_func)(godot_object *, void *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_create_func;
+
+typedef struct {
+	// instance pointer, method data, user data
+	GDCALLINGCONV void (*destroy_func)(godot_object *, void *, void *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_destroy_func;
+
+void GDAPI godot_nativescript_register_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
+
+void GDAPI godot_nativescript_register_tool_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
+
+typedef struct {
+	godot_method_rpc_mode rpc_type;
+} godot_method_attributes;
+
+typedef struct {
+	// instance pointer, method data, user data, num args, args - return result as varaint
+	GDCALLINGCONV godot_variant (*method)(godot_object *, void *, void *, int, godot_variant **);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_method;
+
+void GDAPI godot_nativescript_register_method(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method);
+
+typedef struct {
+	// instance pointer, method data, user data, value
+	GDCALLINGCONV void (*set_func)(godot_object *, void *, void *, godot_variant *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_property_set_func;
+
+typedef struct {
+	// instance pointer, method data, user data, value
+	GDCALLINGCONV godot_variant (*get_func)(godot_object *, void *, void *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_property_get_func;
+
+void GDAPI godot_nativescript_register_property(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func);
+
+typedef struct {
+	godot_string name;
+	godot_int type;
+	godot_property_hint hint;
+	godot_string hint_string;
+	godot_property_usage_flags usage;
+	godot_variant default_value;
+} godot_signal_argument;
+
+typedef struct {
+	godot_string name;
+	int num_args;
+	godot_signal_argument *args;
+	int num_default_args;
+	godot_variant *default_args;
+} godot_signal;
+
+void GDAPI godot_nativescript_register_signal(void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal);
+godot_object GDAPI *godot_nativescript_new(const char *p_classname);
+
+void GDAPI *godot_nativescript_get_userdata(godot_object *p_instance);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

examples/simple/nakefile.nim

@@ -0,0 +1,36 @@
+# Copyright 2017 Xored Software, Inc.
+
+import nake
+import os, ospaths, times
+import apigen.apigen
+
+proc cmdParams(): string =
+  let params = commandLineParams()
+  assert(params.len > 0)
+  result = params[1..<params.len].join(" ")
+
+proc genGodotApi() =
+  let godotBin = getEnv("GODOT_BIN")
+  if godotBin.isNil or godotBin.len == 0:
+    echo "GODOT_BIN environment variable is not set"
+    quit(-1)
+  if not fileExists(godotBin):
+    echo "Invalid GODOT_BIN path: " & godotBin
+    quit(-1)
+
+  const targetDir = "godotapi"
+  createDir(targetDir)
+  const jsonFile = "godotapi"/"api.json"
+  if not fileExists(jsonFile) or
+     godotBin.getLastModificationTime() > jsonFile.getLastModificationTime():
+    direShell(godotBin, "--gdnative-generate-json-api", jsonFile)
+    if not fileExists(jsonFile):
+      echo "Failed to generate api.json"
+      quit(-1)
+
+    genApi(targetDir, jsonFile)
+
+task "build", "Builds the client for the current platform":
+  genGodotApi()
+  withDir "src":
+    direShell("nimble", "make")

examples/simple/project/default_env.tres

@@ -0,0 +1,99 @@
+[gd_resource type="Environment" load_steps=2 format=2]
+
+[sub_resource type="ProceduralSky" id=1]
+
+radiance_size = 4
+sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 )
+sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 )
+sky_curve = 0.25
+sky_energy = 1.0
+ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 )
+ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 )
+ground_curve = 0.01
+ground_energy = 1.0
+sun_color = Color( 1, 1, 1, 1 )
+sun_latitude = 35.0
+sun_longitude = 0.0
+sun_angle_min = 1.0
+sun_angle_max = 100.0
+sun_curve = 0.05
+sun_energy = 16.0
+texture_size = 2
+
+[resource]
+
+background_mode = 2
+background_sky = SubResource( 1 )
+background_sky_scale = 1.0
+background_color = Color( 0, 0, 0, 1 )
+background_energy = 1.0
+background_canvas_max_layer = 0
+ambient_light_color = Color( 0, 0, 0, 1 )
+ambient_light_energy = 1.0
+ambient_light_sky_contribution = 0.0
+fog_enabled = false
+fog_color = Color( 0.5, 0.6, 0.7, 1 )
+fog_sun_color = Color( 1, 0.9, 0.7, 1 )
+fog_sun_amount = 0.0
+fog_depth_enabled = true
+fog_depth_begin = 10.0
+fog_depth_curve = 1.0
+fog_transmit_enabled = false
+fog_transmit_curve = 1.0
+fog_height_enabled = false
+fog_height_min = 0.0
+fog_height_max = 100.0
+fog_height_curve = 1.0
+tonemap_mode = 0
+tonemap_exposure = 1.0
+tonemap_white = 1.0
+auto_exposure_enabled = false
+auto_exposure_scale = 0.4
+auto_exposure_min_luma = 0.05
+auto_exposure_max_luma = 8.0
+auto_exposure_speed = 0.5
+ss_reflections_enabled = false
+ss_reflections_max_steps = 64
+ss_reflections_fade_in = 0.15
+ss_reflections_fade_out = 2.0
+ss_reflections_depth_tolerance = 0.2
+ss_reflections_roughness = true
+ssao_enabled = false
+ssao_radius = 1.0
+ssao_intensity = 1.0
+ssao_radius2 = 0.0
+ssao_intensity2 = 1.0
+ssao_bias = 0.01
+ssao_light_affect = 0.0
+ssao_color = Color( 0, 0, 0, 1 )
+ssao_blur = true
+dof_blur_far_enabled = false
+dof_blur_far_distance = 10.0
+dof_blur_far_transition = 5.0
+dof_blur_far_amount = 0.1
+dof_blur_far_quality = 1
+dof_blur_near_enabled = false
+dof_blur_near_distance = 2.0
+dof_blur_near_transition = 1.0
+dof_blur_near_amount = 0.1
+dof_blur_near_quality = 1
+glow_enabled = false
+glow_levels/1 = false
+glow_levels/2 = false
+glow_levels/3 = true
+glow_levels/4 = false
+glow_levels/5 = true
+glow_levels/6 = false
+glow_levels/7 = false
+glow_intensity = 0.8
+glow_strength = 1.0
+glow_bloom = 0.0
+glow_blend_mode = 2
+glow_hdr_threshold = 1.0
+glow_hdr_scale = 2.0
+glow_bicubic_upscale = false
+adjustment_enabled = false
+adjustment_brightness = 1.0
+adjustment_contrast = 1.0
+adjustment_saturation = 1.0
+

examples/simple/project/fonts/Roboto/RobotoRegular.tres

@@ -0,0 +1,5 @@
+[gd_resource type="DynamicFontData" format=2]
+
+[resource]
+
+font_path = "res://fonts/Roboto/ttf/Roboto-Regular.ttf"

examples/simple/project/fonts/Roboto/ttf/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

examples/simple/project/fps_counter.tscn

@@ -0,0 +1,34 @@
+[gd_scene load_steps=4 format=2]
+
+[ext_resource path="res://fonts/Roboto/RobotoRegular.tres" type="DynamicFontData" id=1]
+[ext_resource path="res://scripts/FPSCounter.gdns" type="Script" id=2]
+
+[sub_resource type="DynamicFont" id=1]
+
+size = 40
+use_mipmaps = false
+use_filter = false
+font_data = ExtResource( 1 )
+_sections_unfolded = [ "Extra Spacing", "Font", "Settings" ]
+
+[node name="Label" type="Label"]
+
+anchor_left = 1
+anchor_right = 1
+margin_top = 10.0
+margin_right = 10.0
+grow_horizontal = 0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+size_flags_horizontal = 1
+size_flags_vertical = 4
+custom_fonts/font = SubResource( 1 )
+text = "FPS: 9000"
+percent_visible = 1.0
+lines_skipped = 0
+max_lines_visible = -1
+script = ExtResource( 2 )
+_sections_unfolded = [ "Anchor", "Grow Direction", "Margin", "custom_colors", "custom_fonts" ]
+
+

examples/simple/project/icon.png.import

@@ -0,0 +1,23 @@
+[remap]
+
+importer="texture"
+type="StreamTexture"
+path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex"
+
+[params]
+
+compress/mode=0
+compress/lossy_quality=0.7
+compress/hdr_mode=0
+compress/normal_map=0
+flags/repeat=0
+flags/filter=true
+flags/mipmaps=false
+flags/anisotropic=false
+flags/srgb=2
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/HDR_as_SRGB=false
+stream=false
+size_limit=0
+detect_3d=true

examples/simple/project/main.tscn

@@ -0,0 +1,50 @@
+[gd_scene load_steps=5 format=2]
+
+[ext_resource path="res://scripts/MainPanel.gdns" type="Script" id=1]
+[ext_resource path="res://fonts/Roboto/RobotoRegular.tres" type="DynamicFontData" id=2]
+[ext_resource path="res://fps_counter.tscn" type="PackedScene" id=3]
+
+[sub_resource type="DynamicFont" id=1]
+
+size = 80
+use_mipmaps = false
+use_filter = false
+font_data = ExtResource( 2 )
+_sections_unfolded = [ "Font", "Settings" ]
+
+[node name="Panel" type="Panel"]
+
+anchor_right = 1
+anchor_bottom = 1
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+script = ExtResource( 1 )
+_sections_unfolded = [ "Anchor", "Margin" ]
+
+[node name="Label" type="Label" parent="."]
+
+anchor_right = 1
+anchor_bottom = 1
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+size_flags_horizontal = 1
+size_flags_vertical = 4
+custom_fonts/font = SubResource( 1 )
+text = "Click me to load scene"
+align = 1
+valign = 1
+percent_visible = 1.0
+lines_skipped = 0
+max_lines_visible = -1
+_sections_unfolded = [ "Anchor", "Margin", "custom_fonts" ]
+
+[node name="FPS" parent="." instance=ExtResource( 3 )]
+
+margin_left = 189.0
+margin_bottom = 58.0
+
+

examples/simple/project/nimlib.tres

@@ -0,0 +1,12 @@
+[gd_resource type="GDNativeLibrary" format=2]
+
+[resource]
+
+platform/X11_32bit = "res://_dlls/nim_linux_32.so"
+platform/X11_64bit = "res://_dlls/nim_linux_64.so"
+platform/Windows_32bit = "res://_dlls/nim_32.dll"
+platform/Windows_64bit = "res://_dlls/nim_64.dll"
+platform/OSX = "res://_dlls/nim_mac.dylib"
+platform/Android = "res://_dlls/nim_android.so"
+platform/iOS = "res://_dlls/nim_ios.dylib"
+platform/WebAssembly = ""

examples/simple/project/project.godot

@@ -0,0 +1,14 @@
+config_version=3
+[application]
+
+config/name="Simple Sample"
+run/main_scene="res://main.tscn"
+config/icon="res://icon.png"
+
+[autoload]
+
+NimRuntime="*res://scripts/NimRuntime.gdns"
+
+[rendering]
+
+environment/default_environment="res://default_env.tres"

examples/simple/project/scene.tscn

@@ -0,0 +1,48 @@
+[gd_scene load_steps=3 format=2]
+
+[ext_resource path="res://fps_counter.tscn" type="PackedScene" id=1]
+
+[sub_resource type="CapsuleMesh" id=1]
+
+radius = 1.0
+mid_height = 1.0
+radial_segments = 64
+rings = 8
+
+[node name="Node" type="Node"]
+
+[node name="MeshInstance" type="MeshInstance" parent="."]
+
+layers = 1
+material_override = null
+cast_shadow = 1
+extra_cull_margin = 0.0
+visible_in_all_rooms = false
+use_in_baked_light = false
+lod_min_distance = 0.0
+lod_min_hysteresis = 0.0
+lod_max_distance = 0.0
+lod_max_hysteresis = 0.0
+mesh = SubResource( 1 )
+skeleton = NodePath("..")
+material/0 = null
+_sections_unfolded = [ "Geometry", "material" ]
+
+[node name="Label" parent="." instance=ExtResource( 1 )]
+
+[node name="Camera" type="Camera" parent="."]
+
+transform = Transform( 0.930689, 0.16529, -0.326338, 0, 0.892097, 0.451845, 0.365811, -0.420527, 0.830265, -0.972205, 1.19673, 2.59579 )
+projection = 0
+fov = 65.0
+near = 0.1
+far = 100.0
+keep_aspect = 1
+current = true
+cull_mask = 1048575
+environment = null
+h_offset = 0.0
+v_offset = 0.0
+doppler/tracking = 0
+
+

examples/simple/project/scripts/FPSCounter.gdns

@@ -0,0 +1,9 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1]
+
+[resource]
+
+resource_name = "FPSCounter"
+library = ExtResource( 1 )
+class_name = "FPSCounter"

examples/simple/project/scripts/MainPanel.gdns

@@ -0,0 +1,9 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1]
+
+[resource]
+
+resource_name = "MainPanel"
+library = ExtResource( 1 )
+class_name = "MainPanel"

examples/simple/project/scripts/NimRuntime.gdns

@@ -0,0 +1,9 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://nimlib.tres" type="GDNativeLibrary" id=1]
+
+[resource]
+
+resource_name = "NimRuntime"
+library = ExtResource( 1 )
+class_name = "NimRuntime"

examples/simple/src/config.nims

@@ -0,0 +1,43 @@
+import ospaths
+
+switch("nimcache", "nimcache"/hostOS/hostCPU)
+
+when defined(macosx):
+  switch("passL", "-framework Cocoa -Wl,-undefined,dynamic_lookup")
+elif defined(android):
+  let ndk = getEnv("ANDROID_NDK_ROOT")
+  let toolchain = getEnv("ANDROID_TOOLCHAIN")
+
+  if ndk.len == 0:
+    raise newException(OSError,
+      "ANDROID_NDK_ROOT environment variable is necessary for android build")
+  if toolchain.len == 0:
+    raise newException(OSError,
+      "ANDROID_TOOLCHAIN environment variable is necessary for android build")
+
+  const level = $16 # change this to the necessary API level
+  const arch = "arm"
+  let sysroot = "--sysroot=\"" & ndk & "/platforms/android-" & level & "/arch-" & arch & "/\""
+  switch("passL", sysroot)
+  switch("passC", sysroot)
+
+  switch("cc", "clang")
+  switch("arm.linux.clang.path", toolchain / "bin")
+  switch("arm.linux.clang.exe", arch & "-linux-androideabi-clang")
+  switch("arm.linux.clang.compilerexe", arch & "-linux-androideabi-clang")
+  switch("arm.linux.clang.linkerexe", arch & "-linux-androideabi-clang")
+elif defined(windows):
+  assert(sizeof(int) == 8)
+  switch("cc", "vcc")
+  let godotLib = getEnv("GODOT_LIB")
+  if godotLib.len == 0:
+    raise newException(OSError,
+      "GODOT_LIB must be specified and point to the .lib file")
+  switch("clib", godotLib.changeFileExt(""))
+elif defined(linux):
+  switch("passC", "-fPIC")
+else:
+  raise newException(OSError, "Unsupported platform: " & hostOS)
+
+when not defined(release):
+  switch("debugger", "native")

examples/simple/src/fpscounter.nim

@@ -0,0 +1,17 @@
+# Copyright 2017 Xored Software, Inc.
+
+import strutils
+import godot
+import engine, label, resource_loader, packed_scene
+
+gdobj FPSCounter of Label:
+  var lastFPS: float32
+
+  method ready*() =
+    setProcess(true)
+
+  method process*(delta: float64) =
+    let fps = getFramesPerSecond()
+    if int(fps * 10) != int(lastFPS * 10):
+      lastFPS = fps
+      self.text = "FPS: " & formatFloat(fps, ffDecimal, 1)

examples/simple/src/mainpanel.nim

@@ -0,0 +1,18 @@
+# Copyright 2017 Xored Software, Inc.
+
+import godot
+import scene_tree, resource_loader, packed_scene, panel, global_constants,
+       input_event_mouse_button
+
+gdobj MainPanel of Panel:
+  method ready*() =
+    setProcessInput(true)
+
+  method input*(event: InputEvent) =
+    if event of InputEventMouseButton:
+      let ev = event as InputEventMouseButton
+      if ev.buttonIndex == BUTTON_LEFT:
+        getTree().setInputAsHandled()
+        let scene = load("res://scene.tscn") as PackedScene
+        getTree().getRoot().addChild(scene.instance())
+        queueFree()

examples/simple/src/nim.cfg

@@ -0,0 +1,9 @@
+--path:"$projectdir"
+--path:"$projectdir/../godotapi"
+--cincludes:"$projectdir/../godot_headers/"
+--experimental
+--app:lib
+--stackTrace:on
+-d:useRealtimeGc
+--noMain
+--warning[LockLevel]:off

examples/simple/src/simple.nim

@@ -0,0 +1,12 @@
+# Copyright 2017 Xored Software, Inc.
+
+## Import independent scene objects here
+## (no need to import everything, just independent roots)
+
+when not defined(release):
+  import segfaults # converts segfaults into NilAccessError
+
+import nimruntime
+
+import fpscounter
+import mainpanel

examples/simple/src/simple.nimble

@@ -0,0 +1,34 @@
+version       = "0.1.0"
+author        = "Xored Software, Inc."
+description   = "FPS Counter Sample"
+license       = "MIT"
+bin           = @["simple"]
+
+requires "https://github.com/pragmagic/godot-nim.git >= 0.2.2 & < 0.3.0"
+
+task make, "build":
+  const archPostfix = when sizeof(int) == 8: "_64" else: "_32"
+  const libFile =
+    when defined(windows):
+      "nim" & archPostfix & ".dll"
+    elif defined(ios):
+      "nim_ios.dylib"
+    elif defined(macosx):
+      "nim_mac.dylib"
+    elif defined(android):
+      "nim_android.so"
+    elif defined(linux):
+      "nim_linux" & archPostfix & ".so"
+    else: nil
+  if libFile.isNil:
+    raise newException(OSError, "Unsupported platform")
+
+  exec "nimble build -y"
+  const dir = "../project/_dlls/"
+  const target = dir & libFile
+  mkDir(dir)
+  when defined(windows):
+    rmFile(target)
+    mvFile(bin[0] & ".exe", target)
+  else:
+    mvFile(bin[0], target)

godot.nimble

@@ -1,7 +1,7 @@
-version = "0.8.2"
+version = "0.2.2"
 author = "Xored Software, Inc."
 description = "Godot Engine bindings"
 license = "MIT"
 srcDir = "godot"
 
-requires "nim >= 0.17.3", "compiler >= 0.17.3"
+requires "nim >= 0.17.0", "compiler >= 0.17.0"

godot/apigen/apigen.nim

@@ -0,0 +1,860 @@
+# Copyright 2017 Xored Software, Inc.
+
+import streams, json, ospaths, strutils, times, sets, tables
+import sequtils, algorithm
+import compiler / [ast, renderer, idents, astalgo]
+
+proc ident(ident: string): PNode =
+  result = newNode(nkIdent)
+  result.ident = getIdent(ident)
+
+proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} =
+  for other in others:
+    node.add(other)
+  result = node
+
+proc newIdentDefs(name, typ: PNode,
+                  defaultVal: PNode = nil): PNode =
+  result = newNode(nkIdentDefs)
+  result.add(name)
+  result.add(typ)
+  if defaultVal.isNil:
+    result.add(newNode(nkEmpty))
+  else:
+    result.add(defaultVal)
+
+proc newProc(name: PNode, params: openArray[PNode], body = newNode(nkEmpty),
+             procType = nkProcDef): PNode =
+  result = newNode(procType)
+  result.add(name)
+  result.add(newNode(nkEmpty))
+  result.add(newNode(nkEmpty))
+  let formalParams = newNode(nkFormalParams)
+  for param in params:
+    formalParams.add(param)
+  result.add(formalParams)
+  result.add(newNode(nkEmpty))
+  result.add(newNode(nkEmpty))
+  result.add(body)
+
+proc newIfStmt(condition, body: PNode): PNode =
+  result = newNode(nkIfStmt)
+  let branch = newNode(nkElifBranch)
+  result.add(branch)
+  branch.add(condition)
+  branch.add(body)
+
+proc newCall(theProc: PNode, args: varargs[PNode]): PNode =
+  result = newNode(nkCall)
+  result.add(theProc)
+  for arg in args:
+    result.add(arg)
+
+proc newCall(theProc: string, args: varargs[PNode]): PNode =
+  newCall(ident(theProc), args)
+
+proc newStrLit(s: string): PNode =
+  result = newNode(nkStrLit)
+  result.strVal = s
+
+proc newRStrLit(s: string): PNode =
+  result = newNode(nkRStrLit)
+  result.strVal = s
+
+proc newCStringLit(s: string): PNode =
+  newNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s))
+
+proc newIntLit(val: BiggestInt): PNode =
+  result = newNode(nkIntLit)
+  result.intVal = val
+
+proc newInt64Lit(val: BiggestInt): PNode =
+  result = newNode(nkInt64Lit)
+  result.intVal = val
+
+proc newFloatLit(val: BiggestFloat): PNode =
+  result = newNode(nkFloatLit)
+  result.floatVal = val
+
+proc newFloat64Lit(val: BiggestFloat): PNode =
+  result = newNode(nkFloat64Lit)
+  result.floatVal = val
+
+proc newNilLit(): PNode =
+  result = newNode(nkNilLit)
+
+proc newDotExpr(left, right: PNode): PNode =
+  result = newNode(nkDotExpr)
+  result.add(left)
+  result.add(right)
+
+proc newCommand(left, right: PNode): PNode =
+  result = newNode(nkCommand)
+  result.add(left)
+  result.add(right)
+
+proc newInfix(left, op, right: PNode): PNode =
+  result = newNode(nkInfix)
+  result.add(op)
+  result.add(left)
+  result.add(right)
+
+proc postfix(left: PNode, op: string): PNode =
+  result = newNode(nkPostfix)
+  result.add(ident(op))
+  result.add(left)
+
+proc newExprColonExpr(key, value: PNode): PNode =
+  newNode(nkExprColonExpr).addChain(key, value)
+
+proc pragma(key: PNode, value: PNode): PNode =
+  newNode(nkPragma).addChain(key, value)
+
+proc newBracketExpr(first, bracket: PNode): PNode =
+  newNode(nkBracketExpr).addChain(first, bracket)
+
+proc newEmptyNode(): PNode =
+  newNode(nkEmpty)
+
+type GodotType = ref object
+  name: string
+  godotName: string
+  baseName: string
+  doc: string
+  derivedCount: int
+  isSingleton: bool
+  jsonNode: JsonNode
+
+proc findCommonRoot(typeRegistry: Table[string, GodotType],
+                    types: seq[string]): string =
+  if types.len == 0: return "Object"
+  var chains = newSeq[seq[string]](types.len)
+  for idx, typ in types:
+    chains[idx] = newSeq[string]()
+    chains[idx].add(typ)
+    var curTyp = typeRegistry[typ]
+    while curTyp.baseName != "NimGodotObject":
+      chains[idx].add(curTyp.baseName)
+      curTyp = typeRegistry[curTyp.baseName]
+    chains[idx].reverse()
+
+  var idx = 0
+  while true:
+    var curType: string
+    var allEqual = true
+    for chain in chains:
+      if idx >= chain.len:
+        allEqual = false
+        break
+      if curType.isNil:
+        curType = chain[idx]
+      elif curType != chain[idx]:
+        allEqual = false
+        break
+    if allEqual:
+      result = curType
+    else:
+      break
+    inc idx
+
+proc incDerivedCount(types: var Table[string, GodotType],
+                     className: string) =
+  let typ = types.getOrDefault(className)
+  if not typ.isNil:
+    inc typ.derivedCount
+    types.incDerivedCount(typ.baseName)
+
+proc toNimType(godotType: string): string =
+  case godotType:
+  of "float": "float64"
+  of "int": "int64"
+  of "String": "string"
+  of "File": "godottypes.File"
+  else: godotType
+
+proc toNimType(types: Table[string, GodotType], godotType: string): string =
+  let origType =
+    if godotType.contains(','):
+      findCommonRoot(types, godotType.split(','))
+    else:
+      godotType
+  result = toNimType(origType)
+
+proc toNimStyle(name: string): string =
+  result = newStringOfCap(name.len + 1)
+  var i = 0
+  var makeUpperCase: bool
+  while i < name.len:
+    if name[i] == '_':
+      if result.len != 0:
+        makeUpperCase = true
+    elif name[i] != '/': # remove slashes
+      if makeUpperCase:
+        result.add(name[i].toUpperAscii())
+        makeUpperCase = false
+      else:
+        result.add(name[i])
+    inc i
+
+  while isKeyword(getIdent(result)):
+    result.add(result[result.len - 1])
+
+  if result == "result":
+    result = "resultVal"
+
+proc newRefTypeNode(typeSection: PNode, typ, base, doc: string,
+                    isExported = true) =
+  let typeDef = newNode(nkTypeDef)
+  typeSection.add(typeDef)
+  if isExported:
+    typeDef.add(postfix(ident(typ), "*"))
+  else:
+    typeDef.add(ident(typ))
+
+  typeDef.add(newNode(nkEmpty)) # generic
+  let objTy = newNode(nkObjectTy)
+  let refTy = newNode(nkRefTy)
+  refTy.add(objTy)
+  typeDef.add(refTy)
+
+  objTy.add(newNode(nkEmpty))
+  let inherit = newNode(nkOfInherit)
+  inherit.add(ident(base))
+  objTy.add(inherit)
+
+  if not doc.isNil:
+    let recList = newNode(nkRecList)
+    let docNode = newNode(nkCommentStmt)
+    docNode.comment = doc
+    recList.add(docNode)
+    objTy.add(recList)
+  else:
+    objTy.add(newNode(nkEmpty))
+
+proc makeConstSection(constObj: JsonNode): PNode =
+  if constObj.len == 0:
+    return newNode(nkEmpty)
+
+  result = newNode(nkConstSection)
+  for field, val in constObj:
+    let def = newNode(nkConstDef)
+    def.add(postfix(ident(field), "*"))
+    def.add(newNode(nkEmpty)) # infer type
+    var valNode: PNode
+    if val.kind == JInt:
+      valNode = newInt64Lit(val.num)
+      # valNode.intVal = val.num
+    elif val.kind == JFloat:
+      valNode = newFloat64Lit(val.fnum)
+    elif val.kind == JBool:
+      valNode = ident($val.bval)
+    elif val.kind == JString:
+      valNode = newNode(nkStrLit)
+      valNode.strVal = val.str
+    else:
+      raise newException(ValueError, "Unexpected constant kind: " & $val.kind)
+    def.add(valNode)
+    result.add(def)
+
+type MethodArg = tuple[name, typ: string, defaultVal: JsonNode, isVarargs: bool]
+
+const standardTypes = toSet(
+  ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32",
+   "uint64",
+   "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2",
+   "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform",
+   "Color", "NodePath", "RID", "Dictionary", "Array", "PoolByteArray",
+   "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array",
+   "PoolVector3Array", "PoolColorArray", "Variant"])
+
+const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32",
+                             "cint", "int", "Error"])
+const int64Types = toSet(["uint64", "int64"])
+const intTypes = union(smallIntTypes, int64Types)
+const float64Types = toSet(["float64", "cdouble"])
+const float32Types = toSet(["float32", "cfloat"])
+const floatTypes = union(float64Types, float32Types)
+const arrayTypes = toSet(["Array", "PoolByteArray",
+  "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array",
+  "PoolVector3Array", "PoolColorArray"])
+
+proc newNilCheck(ident, toAssign: PNode): PNode =
+  newIfStmt(newCall("isNil", ident),
+    newNode(nkAsgn).addChain(ident).addChain(
+      toAssign
+    )
+  )
+
+proc singletonName(typ: string): PNode =
+  ident("singleton" & typ)
+
+proc makeDefaultValue(arg: MethodArg): PNode =
+  result = newEmptyNode()
+  if not arg.defaultVal.isNil:
+    if arg.typ == "bool":
+      result = ident(arg.defaultVal.str.toLowerAscii())
+    elif arg.typ in intTypes:
+      result = newInt64Lit(parseBiggestInt(arg.defaultVal.str))
+    elif arg.typ == "string" or arg.typ == "NodePath":
+      result = newStrLit(arg.defaultVal.str)
+    elif arg.typ in floatTypes:
+      result = newFloatLit(parseFloat(arg.defaultVal.str))
+    elif arg.defaultVal.str == "Null":
+      if arg.typ == "Variant":
+        result = newCall("variant")
+      else:
+        result = newNilLit()
+    elif arg.typ == "Color":
+      result = newCall("initColor",
+          arg.defaultVal.str.split(',').mapIt(newFloatLit(parseFloat(it))))
+    # elif arg.typ in arrayTypes and (arg.defaultVal.str == "[]" or
+    #        arg.defaultVal.str == "[" & arg.typ & "]"):
+    #   result = newCall("init" & arg.typ)
+    elif arg.typ == "RID" and arg.defaultVal.str == "[RID]":
+      result = newCall("initRID")
+    elif arg.typ == "Vector2" or arg.typ == "Vector3" or arg.typ == "Rect2":
+      let parts = arg.defaultVal.str.replace("(", "").replace(")", "").
+                         replace(" ", "").
+                         split(",").mapIt(newFloatLit(parseFloat(it)))
+      if arg.typ.endsWith("r2"):
+        result = newCall("vec2", parts)
+      elif arg.typ.endsWith('3'):
+        result = newCall("vec3", parts)
+      else:
+        result = newCall("initRect2", parts)
+    elif arg.defaultVal.str == "[Object:null]":
+      result = newNilLit()
+    elif arg.typ != "Transform" and arg.typ != "Transform2D" and
+         arg.typ != "Variant" and arg.typ notin arrayTypes: # TODO
+      raise newException(
+        ValueError,
+        "Cannot build default value from $# ($#)" %
+        [$arg.defaultVal, arg.typ])
+
+proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
+                      name: PNode, godotMethodName: string,
+                      typ: GodotType, args: seq[MethodArg],
+                      returnType: string, isVirtual,
+                      isBase, withImplementation: bool) =
+  var body: PNode
+  if not withImplementation:
+    body = newNode(nkEmpty)
+  else:
+    var methodBindName = toNimStyle(
+      typ.name & "_" & godotMethodName & "_method_bind")
+    if methodBindName[0].isUpperAscii():
+      methodBindName[0] = methodBindName[0].toLowerAscii()
+    if methodBindName notin methodBindRegistry:
+      let methodBindDecl = newNode(nkVarSection).addChain(
+        newIdentDefs(
+          newNode(nkPragmaExpr).addChain(
+            ident(methodBindName)).addChain(
+              newNode(nkPragma).addChain(ident("threadvar"))),
+          newNode(nkPtrTy).addChain(ident("GodotMethodBind"))
+        ))
+      tree.add(methodBindDecl)
+      methodBindRegistry.incl(methodBindName)
+
+    let nilCheck = newNilCheck(ident(methodBindName),
+      newCall("getMethod", newCStringLit(typ.godotName),
+        newCStringLit(godotMethodName))
+    )
+    let vars = newNode(nkVarSection)
+    var varargsName: string
+    var isVarargs: bool
+    var staticArgsLen: int
+    var argLenNode = newIntLit(0)
+    let argsName = ident("argsToPassToGodot")
+    if args.len > 0:
+      for arg in args:
+        if arg.isVarargs:
+          varargsName = arg.name
+          isVarargs = true
+          vars.add(newIdentDefs(ident("callError"), ident("VariantCallError")))
+          break
+      let argsAlloc = newNode(nkCast).addChain(
+        newNode(nkPtrTy).addChain(
+          newNode(nkBracketExpr).addChain(
+            ident("array"), ident("MAX_ARG_COUNT"),
+            if isVarargs: ident("Variant") else: ident("pointer"))))
+      staticArgsLen = if varargsName.isNil: args.len
+                      else: args.len - 1
+      if not varargsName.isNil:
+        argLenNode = newCall("cint",
+                      newInfix(newIntLit(staticArgsLen),
+                                ident("+"),
+                                newDotExpr(ident(varargsName), ident("len"))))
+        argsAlloc.add(newCall("godotAlloc", newCall("cint", newInfix(
+          newCall("sizeof", ident("Variant")), ident("*"),
+          newNode(nkPar).addChain(argLenNode))))
+        )
+      else:
+        argLenNode = newCall("cint", newIntLit(staticArgsLen))
+        vars.add(newIdentDefs(
+          ident("argsStatic"),
+          newNode(nkBracketExpr).addChain(
+            ident("array"), newIntLit(staticArgsLen), ident("pointer")),
+          newNode(nkEmpty)))
+        argsAlloc.add(newCommand(ident("addr"), ident("argsStatic")))
+      vars.add(newIdentDefs(argsName, newNode(nkEmpty), argsAlloc))
+
+    let argConversions = newNode(nkStmtList)
+    for idx, arg in args:
+      var argName = ident(arg.name)
+      if arg.isVarargs:
+        argName = newNode(nkBracketExpr).addChain(
+          ident(varargsName),
+          newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen)))
+      let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx)
+      let isStandardType = arg.typ in standardTypes
+      let convArg = if not varargsName.isNil: newCall("toGodot", argName)
+                    elif isStandardType: newCall("unsafeAddr", argName)
+                    elif arg.typ == "string": newCall("unsafeAddr",
+                                  ident("argToPassToGodot" & $idx))
+                    else: ident("argToPassToGodot" & $idx) # object
+      if not isStandardType and arg.isVarargs:
+        raise newException(ValueError,
+          "Non-standard type $# for varargs params of method $# of type $#" %
+            [arg.typ, godotMethodName, typ.godotName])
+      if not isStandardType:
+        if arg.typ == "string":
+          argConversions.add(newNode(nkLetSection).addChain(
+            newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(),
+                         newCall("toGodotString", argName))))
+        else:
+          argConversions.add(newNode(nkLetSection).addChain(
+            newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(),
+                        newDotExpr(argName, ident("godotObject")))))
+      let argAsgn = newNode(nkAsgn).addChain(
+        newNode(nkBracketExpr).addChain(
+          newNode(nkBracketExpr).addChain(argsName), argIdx),
+          convArg
+      )
+      if not arg.isVarargs:
+        argConversions.add(
+          argAsgn
+        )
+      else:
+        argConversions.add(newNode(nkVarSection).addChain(
+          newIdentDefs(ident("idx"), newNode(nkEmpty), newIntLit(staticArgsLen))))
+        let argLoop = newNode(nkWhileStmt)
+        argConversions.add(argLoop)
+        argLoop.add(newInfix(ident("idx"), ident("<"), argLenNode)
+        )
+        argLoop.add(argAsgn)
+        argLoop.add(newCommand(ident("inc"), ident("idx")))
+
+    let retName = if isVarargs: "callRet" else: "ptrCallRet"
+    let theCall = newCall(
+      newDotExpr(ident(methodBindName),
+                 ident(if isVarargs: "call" else: "ptrCall")),
+      newDotExpr(ident("self"), ident("godotObject")),
+      if args.len > 0: argsName else: newNode(nkNilLit),
+      argLenNode,
+      if not isVarargs: ident(retName) else: ident("callError")
+    )
+    if not isVarargs:
+      theCall.sons.delete(3)
+    let freeCall = newCall("godotFree", argsName)
+    body = newNode(nkStmtList)
+    if typ.isSingleton:
+      let varName = singletonName(typ.name)
+      body.add(newNilCheck(varName, newCall(
+        newBracketExpr(ident("getSingleton"), ident(typ.name)))))
+      body.add(newNode(nkLetSection).addChain(newIdentDefs(
+        ident("self"), newNode(nkEmpty), varName
+      )))
+    if not varargsName.isNil:
+      body.add(
+        pragma(ident("push"), newExprColonExpr(
+               newBracketExpr(ident("warning"), ident("Destructor")),
+               ident("off"))))
+    body.add(nilCheck)
+    body.add(vars)
+    body.add(argConversions)
+    if not isVarargs:
+      let retPtrDecl = newNode(nkVarSection).addChain(
+        newIdentDefs(ident(retName), ident("pointer"), newEmptyNode())
+      )
+      body.add(retPtrDecl)
+    var isVariantRet: bool
+    var isConversionRet: bool
+    var isObjRet: bool
+    var isStringRet: bool
+    let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName)
+    if not returnType.isNil and varargsName.isNil:
+      var addrToAssign = newCall("addr", ident("ptrCallVal"))
+      if returnType in smallIntTypes:
+        isConversionRet = true
+        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+          retValIdent, ident("int64"),
+        )))
+      elif returnType in float32Types:
+        isConversionRet = true
+        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+          retValIdent, ident("float64"),
+        )))
+      elif returnType in standardTypes:
+        addrToAssign = newCall("addr", ident("result"))
+      elif returnType == "string":
+        isStringRet = true
+        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+          retValIdent, ident("GodotString"),
+        )))
+      else:
+        isObjRet = true
+        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+          retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")),
+        )))
+      body.add(newNode(nkAsgn).addChain(ident(retName), addrToAssign))
+
+    if not isVarargs:
+      body.add(theCall)
+    else:
+      if not returnType.isNil:
+        isVariantRet = true
+      let callStmt = newNode(nkLetSection).addChain(
+        newIdentDefs(
+          newNode(nkPragmaExpr).addChain(
+            ident(retName), newNode(nkPragma).addChain(ident("used"))),
+          newNode(nkEmpty), theCall))
+      body.add(callStmt)
+    # if not returnType.isNil and not varargsName.isNil:
+    #   body.add(newCall("fromGodot", ident("result"), ident(retName)))
+      # body.add(newCall("deinit", ident(retName)))
+    if args.len > 0 and not varargsName.isNil:
+      body.add(freeCall)
+    if not varargsName.isNil:
+      let errCheck = newIfStmt(
+        newInfix(newDotExpr(ident("callError"), ident("error")), ident("!="),
+                 newDotExpr(ident("VariantCallErrorType"), ident("OK"))),
+        newNode(nkRaiseStmt).addChain(
+          newCall("newCallError", ident("callError")))
+      )
+      body.add(errCheck)
+    if isVariantRet:
+      let convErrDef = newNode(nkLetSection).addChain(
+          newIdentDefs(ident("convErr"), newNode(nkEmpty),
+              newCall("fromGodot", ident("result"), retValIdent)))
+      let convCheck = newIfStmt(
+        newInfix(ident("convErr"), ident("!="),
+                 newDotExpr(ident("ConversionResult"), ident("OK"))),
+        newNode(nkRaiseStmt).addChain(
+          newCall("newConversionError", ident("convErr")))
+      )
+      body.add(convErrDef)
+      body.add(convCheck)
+    if not isVarargs and (isVariantRet or isStringRet):
+      # varargs use call with "let" so destructor is invoked
+      body.add(newCall("deinit", retValIdent))
+    elif isConversionRet:
+      body.add(newNode(nkAsgn).addChain(ident("result"),
+                                        newCall(returnType, retValIdent)))
+    elif isObjRet:
+      body.add(newNode(nkAsgn).addChain(ident("result"),
+               newCall(newBracketExpr(ident("asNimGodotObject"),
+        newCall("type", ident("result"))), retValIdent)))
+    elif isStringRet:
+      body.add(newNode(nkAsgn).addChain(ident("result"),
+                                        newCall("$", retValIdent)))
+    if not varargsName.isNil:
+      body.add(
+        pragma(ident("push"), newExprColonExpr(
+                  newBracketExpr(ident("warning"), ident("Destructor")),
+                  ident("on"))))
+
+  let procType = if isVirtual: nkMethodDef
+                 else: nkProcDef
+  var params = newSeqOfCap[PNode](args.len + 2)
+  if not returnType.isNil:
+    params.add(ident(returnType))
+  else:
+    params.add(newNode(nkEmpty))
+  if not typ.isSingleton:
+    params.add(newIdentDefs(ident("self"), ident(toNimType(typ.name))))
+
+  for arg in args:
+    if arg.isVarargs:
+      params.add(newIdentDefs(ident(arg.name),
+        newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ))))
+    else:
+      let defaultValue = arg.makeDefaultValue()
+      params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue))
+  let procDecl = newProc(if not withImplementation: postfix(name, "*")
+                         else: name,
+                         params, body, procType)
+  if not withImplementation:
+    let pragma = newNode(nkPragma)
+    pragma.add(ident("gcsafe"))
+    pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"),
+                                                newIntLit(0)))
+    if isVirtual and isBase:
+      pragma.add(ident("base"))
+    procDecl.sons[4] = pragma
+  tree.add(procDecl)
+
+proc generateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
+                    name: PNode, godotMethodName: string,
+                    typ: GodotType, args: seq[MethodArg],
+                    returnType: string, isVirtual, isBase, withImplementation: bool) =
+  doGenerateMethod(
+    tree, methodBindRegistry, name, godotMethodName, typ,
+    args, returnType, isVirtual, isBase, withImplementation)
+
+proc makeProperty(types: Table[string, GodotType], tree: PNode,
+                  methodBindRegistry: var HashSet[string],
+                  typ: GodotType,
+                  propertyObj: JsonNode, withImplementation: bool) =
+  let getterNameStr = toNimStyle(propertyObj["name"].str)
+  let getterName = ident(toNimStyle(propertyObj["name"].str))
+  let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "="))
+
+  let nimType = toNimType(types, propertyObj["type"].str)
+  generateMethod(tree, methodBindRegistry,
+                 getterName, propertyObj["getter"].str, typ,
+                 @[], nimType, isVirtual = false,
+                 isBase = false, withImplementation)
+  generateMethod(tree, methodBindRegistry,
+                 setterName, propertyObj["setter"].str, typ,
+                 @[("val", nimType, JsonNode(nil), false)],
+                 nil, isVirtual = false, isBase = false, withImplementation)
+
+proc makeMethod(types: Table[string, GodotType], tree: PNode,
+                methodBindRegistry: var HashSet[string],
+                typ: GodotType, methodObj: JsonNode,
+                withImplementation: bool) =
+  let returnType = if methodObj["return_type"].str != "void":
+                      toNimType(types, methodObj["return_type"].str)
+                   else: nil
+
+  for prop in typ.jsonNode["properties"]:
+    if prop["getter"].str == methodObj["name"].str or
+       prop["setter"].str == methodObj["name"].str:
+      return
+
+  var args = newSeqOfCap[MethodArg](methodObj["arguments"].len + 1)
+  var origArgs = methodObj["arguments"]
+  var isBase = methodObj["is_virtual"].bval
+  if methodObj["is_virtual"].bval:
+    proc getMethod(typNode: JsonNode, methName: string): JsonNode =
+      for meth in typNode["methods"]:
+        if meth["is_virtual"].bval and
+           meth["name"].str == methName: return meth
+    var curTyp = types.getOrDefault(typ.baseName)
+    while not curTyp.isNil:
+      let meth = curTyp.jsonNode.getMethod(methodObj["name"].str)
+      if not meth.isNil:
+        origArgs = meth["arguments"]
+        isBase = false
+      curTyp = types.getOrDefault(curTyp.baseName)
+
+  for arg in origArgs:
+    let typ = toNimType(types, arg["type"].str)
+    let defaultVal = if arg["has_default_value"].bval: arg["default_value"]
+                     else: nil
+    args.add((toNimStyle(arg["name"].str), typ,
+              defaultVal, false))
+  if methodObj["has_varargs"].bval:
+    args.add(("variantArgs", "Variant", JsonNode(nil), true))
+
+  let godotName = methodObj["name"].str
+  generateMethod(tree, methodBindRegistry,
+                 ident(toNimStyle(godotName)), methodObj["name"].str,
+                 typ, args,
+                 returnType, methodObj["is_virtual"].bval, isBase,
+                 withImplementation)
+
+proc addAttributeToDoc(doc: var string, propName, propValue: string) =
+  if doc.len > 0:
+    doc.add("\n")
+  doc.add(propName & ": " & propValue)
+
+const classAttributes = ["singleton", "instanciable", "is_reference"]
+
+proc typeNameToModuleName(name: string): string =
+  var wasUpperOrDigit = true
+  result = newStringOfCap(name.len + 10)
+  for idx, c in name:
+    if c.isUpperAscii() or c.isDigit():
+      if not wasUpperOrDigit or idx > 0 and idx < name.len - 1 and
+         name[idx + 1].isLowerAscii():
+        result.add('_')
+      result.add(c.toLowerAscii())
+      wasUpperOrDigit = true
+    else:
+      result.add(c)
+      wasUpperOrDigit = false
+  if result == "object":
+    # keyword
+    result = "objects"
+  if result == "os":
+    # to avoid clash with stdlib
+    result = "gd_os"
+
+proc newRegisterClassNode(typ: GodotType): PNode =
+  newCall("registerClass",
+    ident(typ.name),
+    newCStringLit(typ.godotName),
+    ident("true") # isNative
+  )
+
+proc genSingletonDecl(typ: string): PNode =
+  result = newNode(nkVarSection)
+  let name = singletonName(typ)
+  let threadvar = newNode(nkPragma).addChain(ident("threadvar"))
+  result.add(newIdentDefs(newNode(nkPragmaExpr).addChain(name, threadvar),
+             ident(typ)))
+
+proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool =
+  var curTyp = typ
+  while not curTyp.isNil and not curTyp.isSingleton:
+    curTyp = types.getOrDefault(curTyp.baseName)
+  result = curTyp.isNil
+
+proc genTypeFile*(types: var Table[string, GodotType], targetDir: string) =
+  for typ in types.values():
+    types.incDerivedCount(typ.baseName)
+
+  var sortedTypes = toSeq(types.values())
+  sortedTypes.sort do (x, y: GodotType) -> int:
+    cmp(y.derivedCount, x.derivedCount)
+
+  let godotApiTypesTree = newNode(nkStmtList)
+  godotApiTypesTree.add(newNode(nkImportStmt).addChain(ident("godot")))
+  let typeSection = newNode(nkTypeSection)
+  godotApiTypesTree.add(typeSection)
+
+  for typ in sortedTypes:
+    if not typ.shouldExport(types): continue
+    newRefTypeNode(typeSection, typ.name, typ.baseName, typ.doc)
+
+  for typ in sortedTypes:
+    if not typ.shouldExport(types): continue
+    let regNode = newCall("registerClass",
+      ident(typ.name),
+      newCStringLit(typ.godotName),
+      ident("true") # isNative
+    )
+    godotApiTypesTree.add(regNode)
+
+  renderModule(godotApiTypesTree, targetDir / "godottypes.nim")
+
+proc genApi*(targetDir: string, apiJsonFile: string) =
+  let apiJson = parseJson(newFileStream(apiJsonFile),
+                          apiJsonFile.extractFilename())
+  var megaImport = newStringOfCap(64 * 1024)
+
+  var types = initTable[string, GodotType]()
+  for obj in apiJson:
+    let godotClassName = obj["name"].str
+    let className = godotClassName.replace("_", "")
+    var baseClassName = obj["base_class"].str
+    baseClassName = toNimType(baseClassName.replace("_", ""))
+    if baseClassName.isNil or baseClassName.len == 0:
+      baseClassName = "NimGodotObject"
+    var doc = ""
+    for attr in classAttributes:
+      if attr in obj:
+        addAttributeToDoc(doc, attr, $obj[attr])
+    types[className] = GodotType(
+      name: className,
+      godotName: godotClassName,
+      baseName: baseClassName,
+      doc: doc,
+      jsonNode: obj,
+      isSingleton: obj["singleton"].bval
+    )
+  for typ in types.values():
+    let tree = newNode(nkStmtList)
+    let importStmt = newNode(nkImportStmt)
+    importStmt.add(ident("godot"))
+    importStmt.add(ident("godottypes"))
+    importStmt.add(newDotExpr(ident("core"), ident("godotcore")))
+    tree.add(importStmt)
+    let exportStmt = newNode(nkExportStmt)
+    exportStmt.add(ident("godottypes"))
+    tree.add(exportStmt)
+
+    var methodBindRegsitry = initSet[string]()
+    let obj = typ.jsonNode
+    if typ.baseName != "NimGodotObject":
+      let baseModule = typeNameToModuleName(typ.baseName)
+      let baseModuleNode = if getIdent(baseModule).isKeyword:
+                             newStrLit(baseModule & ".nim")
+                           else:
+                             ident(baseModule)
+      importStmt.add(baseModuleNode)
+      exportStmt.add(baseModuleNode)
+    let constSection = makeConstSection(obj["constants"])
+    if constSection.kind != nkEmpty:
+      # renderer doesn't properly render empty stmt after type section
+      tree.add(makeConstSection(obj["constants"]))
+
+    if typ.isSingleton:
+      let typeDecl = newNode(nkTypeSection)
+      newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc,
+                     isExported = false)
+      tree.add(typeDecl)
+      tree.add(newRegisterClassNode(typ))
+      tree.add(genSingletonDecl(typ.name))
+
+    # first, generate declarations only for ease of
+    # human readability of the file
+    for property in obj["properties"]:
+      makeProperty(types, tree, methodBindRegsitry, typ, property,
+                   withImplementation = false)
+    for meth in obj["methods"]:
+      makeMethod(types, tree, methodBindRegsitry, typ,
+                 meth, withImplementation = false)
+
+    for property in obj["properties"]:
+      makeProperty(types, tree, methodBindRegsitry, typ,
+                   property, withImplementation = true)
+    for meth in obj["methods"]:
+      makeMethod(types, tree, methodBindRegsitry, typ, meth,
+                 withImplementation = true)
+
+    let moduleName = typeNameToModuleName(typ.name)
+    renderModule(tree, targetDir / moduleName & ".nim")
+
+    megaImport.add("import \"" & moduleName & "\"\n")
+
+  genTypeFile(types, targetDir)
+
+  writeFile(targetDir / "godotall.nim", megaImport)
+  writeFile(targetDir / splitPath(targetDir)[1] & ".nimble", "")
+
+when isMainModule:
+  import os
+
+  const usage = slurp("usage.txt")
+
+  proc main() =
+    if paramCount() < 2:
+      echo usage
+      quit(-1)
+    let godotBin = paramStr(1)
+    let targetDir = paramStr(2)
+
+    if not dirExists(targetDir):
+      echo "The specified directory does not exist"
+      quit(-1)
+    if not fileExists(godotBin):
+      echo "Invalid godot binary path"
+      quit(-1)
+
+    let jsonFile = targetDir / "api.json"
+    if fileExists(jsonFile) and
+       godotBin.getLastModificationTime() <= jsonFile.getLastModificationTime():
+      echo "api.json if up to date - doing nothing."
+      return
+
+    discard execShellCmd(
+      "\"" & godotBin & "\" --gdnative-generate-json-api \"" & jsonFile & "\"")
+    if not fileExists(jsonFile):
+      echo "Failed to generate api.json"
+      quit(-1)
+
+    genApi(targetDir, jsonFile)
+
+  main()

godot/apigen/usage.txt

@@ -0,0 +1,3 @@
+Tool for wrapping Godot API into Nim
+
+    apigen [godot binary path] [target directory]

godot/core/aabb.nim

@@ -1,79 +0,0 @@
-# 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)

godot/core/arrays.nim

@@ -1,146 +1,145 @@
-# Copyright 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
 import hashes
-import internal/godotinternaltypes, internal/godotarrays
+import godotbase, poolarray, variant, strings
 
-type
-  Array* = ref object
-    godotArray: GodotArray
+proc initArray(dest: var Array) {.
+    importc: "godot_array_new", header: "godot/array.h".}
+proc initArray(dest: var Array; pca: PoolColorArray) {.
+    importc: "godot_array_new_pool_coloarray",
+    header: "godot/array.h".}
+proc initArray(dest: var Array; pv3a: PoolVector3Array) {.
+    importc: "godot_array_new_pool_vector3_array",
+    header: "godot/array.h".}
+proc initArray(dest: var Array; pv2a: PoolVector2Array) {.
+    importc: "godot_array_new_pool_vector2_array",
+    header: "godot/array.h".}
+proc initArray(dest: var Array; psa: PoolStringArray) {.
+    importc: "godot_array_new_pool_string_array",
+    header: "godot/array.h".}
+proc initArray(dest: var Array; pra: PoolRealArray) {.
+    importc: "godot_array_new_pool_real_array",
+    header: "godot/array.h".}
+proc initArray(dest: var Array; pia: PoolIntArray) {.
+    importc: "godot_array_new_pool_int_array",
+    header: "godot/array.h".}
+proc initArray(dest: var Array; pba: PoolByteArray) {.
+    importc: "godot_array_new_pool_byte_array",
+    header: "godot/array.h".}
 
-proc godotArray*(arr: Array): ptr GodotArray {.inline.} =
-  ## WARNING: do not keep the returned value for longer than the lifetime of
-  ## ``arr``
-  addr arr.godotArray
+proc initArray*(): Array {.inline.} =
+  initArray(result)
 
-proc arrayFinalizer(arr: Array) =
-  arr.godotArray.deinit()
+proc initArray*(pca: PoolColorArray): Array {.inline.} =
+  initArray(result, pca)
 
-proc newArray*(arr: GodotArray): Array {.inline.} =
-  new(result, arrayFinalizer)
-  result.godotArray = arr
+proc initArray*(pv3a: PoolVector3Array): Array {.inline.} =
+  initArray(result, pv3a)
 
-import variants
+proc initArray*(pv2a: PoolVector2Array): Array {.inline.} =
+  initArray(result, pv2a)
 
-proc newArray*(s: varargs[Variant]): Array =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray)
-  for v in s:
-    result.godotArray.add(v.godotVariant[])
+proc initArray*(psa: PoolStringArray): Array {.inline.} =
+  initArray(result, psa)
 
-proc newArray*(s: openarray[Variant]): Array =
-  result = newArray()
-  for v in s:
-    result.godotArray.add(v.godotVariant[])
+proc initArray*(pra: PoolRealArray): Array {.inline.} =
+  initArray(result, pra)
 
-import poolarrays
+proc initArray*(pia: PoolIntArray): Array {.inline.} =
+  initArray(result, pia)
 
-proc newArray*(pca: PoolColorArray): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, pca.godotPoolColorArray[])
+proc initArray*(pba: PoolByteArray): Array {.inline.} =
+  initArray(result, pba)
 
-proc newArray*(pv3a: PoolVector3Array): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, pv3a.godotPoolVector3Array[])
+proc `[]=`*(self: var Array; idx: cint;
+            value: Variant) {.
+    noSideEffect,
+    importc: "godot_array_set", header: "godot/array.h".}
+proc `[]`*(self: Array; idx: cint): Variant {.
+    noSideEffect,
+    importc: "godot_array_get", header: "godot/array.h".}
+proc mget*(self: var Array; idx: cint): ptr Variant {.
+    importc: "godot_array_operator_index", header: "godot/array.h".}
 
-proc newArray*(pv2a: PoolVector2Array): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, pv2a.godotPoolVector2Array[])
-
-proc newArray*(psa: PoolStringArray): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, psa.godotPoolStringArray[])
-
-proc newArray*(pra: PoolRealArray): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, pra.godotPoolRealArray[])
-
-proc newArray*(pia: PoolIntArray): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, pia.godotPoolIntArray[])
-
-proc newArray*(pba: PoolByteArray): Array {.inline.} =
-  new(result, arrayFinalizer)
-  initGodotArray(result.godotArray, pba.godotPoolByteArray[])
-
-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: Array; value: Variant) {.inline.} =
-  self.godotArray.add(value.godotVariant[])
-
-proc clear*(self: Array) {.inline.} =
-  self.godotArray.clear()
-
-proc count*(self: Array; value: Variant): int {.inline.} =
-  self.godotArray.count(value.godotVariant[]).int
-
-proc isEmpty*(self: Array): bool {.inline.} =
-  self.godotArray.isEmpty()
-
-proc erase*(self: Array; value: Variant) {.inline.} =
-  self.godotArray.erase(value.godotVariant[])
-
-proc first*(self: Array): Variant {.inline.} =
-  newVariant(self.godotArray.first())
-
-proc last*(self: Array): Variant {.inline.} =
-  newVariant(self.godotArray.last())
-
-proc find*(self: Array; what: Variant; f: int): int {.inline.} =
-  self.godotArray.find(what.godotVariant[], f.cint).int
-
-proc findLast*(self: Array; what: Variant): int {.inline.} =
-  self.godotArray.findLast(what.godotVariant[]).int
-
-proc contains*(self: Array; value: Variant): bool {.inline.} =
-  self.godotArray.contains(value.godotVariant[])
+proc add*(self: var Array; value: Variant) {.
+    noSideEffect,
+    importc: "godot_array_append", header: "godot/array.h".}
+proc clear*(self: var Array) {.importc: "godot_array_clear",
+                                    header: "godot/array.h".}
+proc count*(self: Array; value: Variant): cint {.
+    noSideEffect,
+    importc: "godot_array_count", header: "godot/array.h".}
+proc isEmpty*(self: Array): bool {.
+    noSideEffect,
+    importc: "godot_array_empty", header: "godot/array.h".}
+proc erase*(self: var Array; value: Variant) {.
+    importc: "godot_array_erase", header: "godot/array.h".}
+proc first*(self: Array): Variant {.
+    noSideEffect,
+    importc: "godot_array_front", header: "godot/array.h".}
+proc last*(self: Array): Variant {.
+    noSideEffect,
+    importc: "godot_array_back", header: "godot/array.h".}
+proc find*(self: Array; what: Variant;
+           f: cint): cint {.
+    noSideEffect,
+    importc: "godot_array_find", header: "godot/array.h".}
+proc findLast*(self: Array; what: Variant): cint {.
+    noSideEffect,
+    importc: "godot_array_find_last", header: "godot/array.h".}
+proc contains*(self: Array; value: Variant): bool {.
+    noSideEffect,
+    importc: "godot_array_has", header: "godot/array.h".}
 
+proc godotHash*(self: Array): cint {.
+    noSideEffect,
+    importc: "godot_array_hash", header: "godot/array.h".}
 proc hash*(self: Array): Hash {.inline.} =
-  hash(self.godotArray.godotHash())
+  hash(godotHash(self))
 
-proc insert*(self: Array; pos: int; value: Variant) {.inline.} =
-  self.godotArray.insert(pos.cint, value.godotVariant[])
+proc insert*(self: var Array; pos: cint;
+             value: Variant) {.
+    importc: "godot_array_insert", header: "godot/array.h".}
+proc reverse*(self: var Array) {.importc: "godot_array_invert",
+    header: "godot/array.h".}
+proc popLast*(self: var Array): Variant {.
+    importc: "godot_array_pop_back", header: "godot/array.h".}
+proc popFirst*(self: var Array): Variant {.
+    importc: "godot_array_pop_front", header: "godot/array.h".}
+proc addLast*(self: var Array; value: Variant) {.
+    importc: "godot_array_push_back", header: "godot/array.h".}
+proc addFirst*(self: var Array; value: Variant) {.
+    importc: "godot_array_push_front", header: "godot/array.h".}
 
-proc reverse*(self: Array) {.inline.} =
-  self.godotArray.reverse()
+proc delete*(self: var Array; idx: cint) {.
+    importc: "godot_array_remove", header: "godot/array.h".}
+proc setLen*(self: var Array; size: cint) {.
+    importc: "godot_array_resize", header: "godot/array.h".}
+proc rfind*(self: Array; what: Variant;
+            f: cint): cint {.
+    noSideEffect,
+    importc: "godot_array_rfind", header: "godot/array.h".}
+proc len*(self: Array): cint {.
+    noSideEffect,
+    importc: "godot_array_size", header: "godot/array.h".}
+proc sort*(self: var Array) {.importc: "godot_array_sort",
+    header: "godot/array.h".}
+proc sortCustom*(self: var Array; obj: var GodotObject;
+                 funcName: GodotString) {.
+    importc: "godot_array_sort_custom", header: "godot/array.h".}
 
-proc popLast*(self: Array): Variant {.inline.} =
-  newVariant(self.godotArray.popLast())
+iterator items*(arr: Array): Variant =
+  for i in 0..<arr.len:
+    yield arr[i]
 
-proc popFirst*(self: Array): Variant {.inline.} =
-  newVariant(self.godotArray.popFirst())
+iterator mitems*(arr: var Array): var Variant =
+  for i in 0..<arr.len:
+    yield arr.mget(i)[]
 
-proc addLast*(self: Array; value: Variant) {.inline.} =
-  self.godotArray.addLast(value.godotVariant[])
+iterator pairs*(arr: Array): tuple[key: cint, val: Variant] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
 
-proc addFirst*(self: Array; value: Variant) {.inline.} =
-  self.godotArray.addFirst(value.godotVariant[])
-
-proc delete*(self: Array; idx: int) {.inline.} =
-  self.godotArray.delete(idx.cint)
-
-proc setLen*(self: Array; size: int) {.inline.} =
-  self.godotArray.setLen(size.cint)
-
-proc rfind*(self: Array; what: Variant; fromIdx: int): int {.inline.} =
-  self.godotArray.rfind(what.godotVariant[], fromIdx.cint).int
-
-proc len*(self: Array): int {.inline.} =
-  self.godotArray.len.int
-
-proc sort*(self: Array) {.inline.} =
-  self.godotArray.sort()
-
-iterator items*(self: Array): Variant =
-  for i in 0..<self.len:
-    yield self[i]
-
-iterator pairs*(self: Array): tuple[key: int, val: Variant] =
-  for i in 0..<self.len:
-    yield (i, self[i])
-
-proc `$`*(self: Array): string =
-  $self.godotArray
+iterator mpairs*(arr: var Array): tuple[key: cint, val: var Variant] =
+  for i in 0..<arr.len:
+    yield (i, arr.mget(i)[])

godot/core/basis.nim

@@ -1,459 +1,140 @@
-# Copyright (c) 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
-import math, hashes
+import godotbase, vector3, quat, strings
 
-import godotbase, vector3, quats
-import godotcoretypes
+type
+  Basis* {.importc: "godot_basis", header: "godot/basis.h", byref.} = object
 
-{.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
-  basis.elements[0].z = xz
-  basis.elements[1].x = yx
-  basis.elements[1].y = yy
-  basis.elements[1].z = yz
-  basis.elements[2].x = zx
-  basis.elements[2].y = zy
-  basis.elements[2].z = zz
-
-proc `[]`*(self: Basis; row: range[0..2]): Vector3 {.inline.} =
-  self.elements[row]
-
-proc `[]`*(self: var Basis; row: range[0..2]): var Vector3 {.inline.} =
-  self.elements[row]
-
-proc `[]=`*(self: var Basis; row: range[0..2];
-            value: Vector3) {.inline.} =
-  self.elements[row] = value
-
-proc `==`*(self, other: Basis): bool =
-  for i in 0..2:
-    for j in 0..2:
-      if self[i][j] != other[i][j]:
-        return false
-  result = true
-
-proc isEqualApprox*(self, other: Basis): bool =
-  for i in 0..2:
-    for j in 0..2:
-      if not self[i][j].isEqualApprox(other[i][j]):
-        return false
-  result = true
-
-proc tdotx*(self: Basis; v: Vector3): float32 {.inline.} =
-  self.elements[0].x * v.x + self.elements[1].x * v.y + self.elements[2].x * v.z
-
-proc tdoty*(self: Basis; v: Vector3): float32 {.inline.} =
-  self.elements[0].y * v.x + self.elements[1].y * v.y + self.elements[2].y * v.z
-
-proc tdotz*(self: Basis; v: Vector3): float32 {.inline.} =
-  self.elements[0].z * v.x + self.elements[1].z * v.y + self.elements[2].z * v.z
-
-proc `+`*(self, other: Basis): Basis {.inline.} =
-  result[0] = self[0] + other[0]
-  result[1] = self[1] + other[1]
-  result[2] = self[2] + other[2]
-
-proc `+=`*(self: var Basis, other: Basis) {.inline.} =
-  self[0] += other[0]
-  self[1] += other[1]
-  self[2] += other[2]
-
-proc `-`*(self, other: Basis): Basis {.inline.} =
-  result[0] = self[0] - other[0]
-  result[1] = self[1] - other[1]
-  result[2] = self[2] - other[2]
-
-proc `-=`*(self: var Basis, other: Basis) {.inline.} =
-  self[0] -= other[0]
-  self[1] -= other[1]
-  self[2] -= other[2]
-
-proc `*`*(self, other: Basis): Basis {.inline.} =
-  result.setCells(
-    other.tdotx(self[0]), other.tdoty(self[0]), other.tdotz(self[0]),
-    other.tdotx(self[1]), other.tdoty(self[1]), other.tdotz(self[1]),
-    other.tdotx(self[2]), other.tdoty(self[2]), other.tdotz(self[2])
-  )
-
-proc `*=`*(self: var Basis, other: Basis) {.inline.} =
-  self.setCells(
-    other.tdotx(self[0]), other.tdoty(self[0]), other.tdotz(self[0]),
-    other.tdotx(self[1]), other.tdoty(self[1]), other.tdotz(self[1]),
-    other.tdotx(self[2]), other.tdoty(self[2]), other.tdotz(self[2])
-  )
-
-proc `*=`*(self: var Basis; b: float32) {.inline.} =
-  self[0] *= b
-  self[1] *= b
-  self[2] *= b
-
-proc `*`*(self: Basis; b: float32): Basis {.inline.} =
-  result = self
-  result *= b
+proc initBasis(dest: var Basis) {.importc: "godot_basis_new",
+    header: "godot/basis.h".}
+proc initBasis(dest: var Basis;
+               xAxis: Vector3;
+               yAxis: Vector3;
+               zAxis: Vector3) {.
+    importc: "godot_basis_new_with_rows", header: "godot/basis.h".}
+proc initBasis(dest: var Basis;
+               euler: Quat) {.
+    importc: "godot_basis_new_with_euler_quat", header: "godot/basis.h".}
+proc initBasis(dest: var Basis; axis: Vector3; phi: float32) {.
+    importc: "godot_basis_new_with_axis_and_angle", header: "godot/basis.h".}
+proc initBasis(dest: var Basis; euler: Vector3) {.
+    importc: "godot_basis_new_with_euler", header: "godot/basis.h".}
 
 proc initBasis*(): Basis {.inline.} =
-  result.setCells(
-    1, 0, 0,
-    0, 1, 0,
-    0, 0, 1
-  )
+  initBasis(result)
 
-proc initBasis*(row0, row1, row2: Vector3): Basis {.inline.} =
-  Basis(elements: [row0, row1, row2])
-
-proc initBasis*(xx, xy, xz, yx, yy, yz, zx, zy, zz: float32): Basis =
-  result.setCells(xx, xy, xz, yx, yy, yz, zx, zy, zz)
+proc initBasis*(xAxis, yAxis, zAxis: Vector3): Basis {.inline.} =
+  initBasis(result, xAxis, yAxis, zAxis)
 
 proc initBasis*(euler: Quat): Basis {.inline.} =
-  let d = euler.lengthSquared()
-  let s = 2.0 / d
-  let xs = euler.x * s
-  let ys = euler.y * s
-  let zs = euler.z * s
-  let wx = euler.w * xs
-  let wy = euler.w * ys
-  let wz = euler.w * zs
-  let xx = euler.x * xs
-  let xy = euler.x * ys
-  let xz = euler.x * zs
-  let yy = euler.y * ys
-  let yz = euler.y * zs
-  let zz = euler.z * zs
-  result.setCells(
-    1.0 - (yy + zz), xy - wz, xz + wy,
-    xy + wz, 1.0 - (xx + zz), yz - wx,
-    xz - wy, yz + wx, 1.0 - (xx + yy))
-
-proc setAxisAngle(self: var Basis, axis: Vector3, phi: float32) =
-  assert(axis.isNormalized())
-  let axisSq = vec3(axis.x * axis.x, axis.y * axis.y, axis.z * axis.z)
-
-  let cosine = cos(phi);
-  let sine = sin(phi);
-
-  self.elements[0].x = axisSq.x + cosine * (1.0 - axisSq.x)
-  self.elements[0].y = axis.x * axis.y * (1.0 - cosine) - axis.z * sine
-  self.elements[0].z = axis.z * axis.x * (1.0 - cosine) + axis.y * sine
-
-  self.elements[1].x = axis.x * axis.y * (1.0 - cosine) + axis.z * sine
-  self.elements[1].y = axisSq.y + cosine * (1.0 - axisSq.y)
-  self.elements[1].z = axis.y * axis.z * (1.0 - cosine) - axis.x * sine
-
-  self.elements[2].x = axis.z * axis.x * (1.0 - cosine) - axis.y * sine
-  self.elements[2].y = axis.y * axis.z * (1.0 - cosine) + axis.x * sine
-  self.elements[2].z = axisSq.z + cosine * (1.0 - axisSq.z)
+  initBasis(result, euler)
 
 proc initBasis*(axis: Vector3, phi: float32): Basis  {.inline.} =
-  result.setAxisAngle(axis, phi)
-
-proc setEuler*(self: var Basis, euler: Vector3) =
-  var c = cos(euler.x)
-  var s = sin(euler.x)
-
-  let xmat = initBasis(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c)
-
-  c = cos(euler.y)
-  s = sin(euler.y)
-  let ymat = initBasis(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c)
-
-  c = cos(euler.z)
-  s = sin(euler.z)
-  let zmat = initBasis(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0)
-
-  self = xmat * (ymat * zmat)
-
-proc getEuler*(self: Basis): Vector3 =
-  result.y = arcsin(self.elements[0].z)
-  if result.y < PI * 0.5:
-    if result.y > -PI * 0.5:
-      result.x = arctan2(-self.elements[1].z, self.elements[2].z)
-      result.z = arctan2(-self.elements[0].y, self.elements[0].x)
-    else:
-      let r = arctan2(self.elements[1].x, self.elements[1].y)
-      result.x = -r
-  else:
-    let r = arctan2(self.elements[0].y, self.elements[1].y)
-    result.x = r
+  initBasis(result, axis, phi)
 
 proc initBasis*(euler: Vector3): Basis {.inline.} =
-  result.setEuler(euler)
+  initBasis(result, euler)
 
-proc outer*(self, other: Vector3): Basis {.inline.} =
-  let row0 = vec3(self.x * other.x, self.x * other.y, self.x * other.z)
-  let row1 = vec3(self.y * other.x, self.y * other.y, self.y * other.z)
-  let row2 = vec3(self.z * other.x, self.z * other.y, self.z * other.z)
-  initBasis(row0, row1, row2)
-
-proc toDiagonalMatrix*(self: Vector3): Basis {.inline.} =
-  initBasis(
-    self.x, 0, 0,
-    0, self.y, 0,
-    0, 0, self.z
-  )
+proc toGodotString*(self: Basis): GodotString {.
+    noSideEffect,
+    importc: "godot_basis_as_string", header: "godot/basis.h".}
 
 proc `$`*(self: Basis): string {.inline.} =
-  result = newStringOfCap(128)
-  for i in 0..2:
-    for j in 0..2:
-      if i != 0 or j != 0:
-        result.add(", ")
-      result.add($self[i][j])
+  $self.toGodotString()
 
-proc hash*(self: Basis): Hash {.inline.} =
-  !$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash())
+proc inverse*(self: Basis): Basis {.
+    noSideEffect,
+    importc: "godot_basis_inverse", header: "godot/basis.h".}
+proc transposed*(self: Basis): Basis {.
+    noSideEffect,
+    importc: "godot_basis_transposed", header: "godot/basis.h".}
+proc orthonormalized*(self: Basis): Basis {.
+    noSideEffect,
+    importc: "godot_basis_orthonormalized", header: "godot/basis.h".}
+proc determinant*(self: Basis): float32 {.
+    noSideEffect,
+    importc: "godot_basis_determinant", header: "godot/basis.h".}
+proc rotated*(self: Basis; axis: Vector3;
+              phi: float32): Basis {.
+    noSideEffect,
+    importc: "godot_basis_rotated", header: "godot/basis.h".}
+proc scaled*(self: Basis; scale: Vector3): Basis {.
+    noSideEffect,
+    importc: "godot_basis_scaled", header: "godot/basis.h".}
 
-template cofac(row1, col1, row2, col2: int): float32 =
-  self.elements[row1][col1] * self.elements[row2][col2] -
-    self.elements[row1][col2] * self.elements[row2][col1]
+proc setScale*(self: var Basis; scale: Vector3) {.
+    noSideEffect,
+    importc: "godot_basis_set_scale", header: "godot/basis.h".}
+proc setRotationEuler*(self: var Basis;
+                       euler: Vector3) {.
+    noSideEffect,
+    importc: "godot_basis_set_rotation_euler", header: "godot/basis.h".}
+proc setRotationAxisAngle*(self: var Basis; axis: Vector3; angle: float32) {.
+    noSideEffect,
+    importc: "godot_basis_set_rotation_axis_angle", header: "godot/basis.h".}
 
-proc determinant(self: Basis): float32 {.inline.} =
-  self[0][0] * cofac(1, 1, 2, 2) -
-    self[1][0] * cofac(0, 1, 2, 2) +
-    self[2][0] * cofac(0, 1, 1, 2)
+proc scale*(self: Basis): Vector3 {.
+    noSideEffect,
+    importc: "godot_basis_get_scale", header: "godot/basis.h".}
+proc euler*(self: Basis): Vector3 {.
+    noSideEffect,
+    importc: "godot_basis_get_euler", header: "godot/basis.h".}
 
-proc invert*(self: var Basis) =
-  let co = [cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1)]
-  let det = self.elements[0][0] * co[0] +
-            self.elements[0][1] * co[1] +
-            self.elements[0][2] * co[2]
-  assert(det != 0)
-  let s = 1.0'f32 / det
-  self.setCells(
-    co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
-    co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
-    co[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s
-  )
+proc tdotx*(self: Basis; x: Vector3): float32 {.
+    noSideEffect,
+    importc: "godot_basis_tdotx", header: "godot/basis.h".}
+proc tdoty*(self: Basis; y: Vector3): float32 {.
+    noSideEffect,
+    importc: "godot_basis_tdoty", header: "godot/basis.h".}
+proc tdotz*(self: Basis; z: Vector3): float32 {.
+    noSideEffect,
+    importc: "godot_basis_tdotz", header: "godot/basis.h".}
 
-proc inverse*(self: Basis): Basis {.inline.} =
-  result = self
-  result.invert()
+proc xform*(self: Basis; v: Vector3): Vector3 {.
+    noSideEffect,
+    importc: "godot_basis_xform", header: "godot/basis.h".}
+proc xformInv*(self: Basis; v: Vector3): Vector3 {.
+    noSideEffect,
+    importc: "godot_basis_xform_inv", header: "godot/basis.h".}
 
-proc axis*(self: Basis; idx: range[0..2]): Vector3 {.inline.} =
-  vec3(self[0][idx], self[1][idx], self[2][idx])
+proc orthogonalIndex*(self: Basis): cint {.
+    noSideEffect,
+    importc: "godot_basis_get_orthogonal_index", header: "godot/basis.h".}
 
-proc setAxis*(self: var Basis; idx: range[0..2]; value: Vector3) {.inline.} =
-  self.elements[0][idx] = value.x
-  self.elements[1][idx] = value.y
-  self.elements[2][idx] = value.z
+proc godot_basis_get_elements(self: Basis;
+                              elements: var array[3, Vector3]) {.
+    noSideEffect,
+    importc: "godot_basis_get_elements", header: "godot/basis.h".}
 
-proc row*(self: Basis; row: range[0..2]): Vector3 {.inline.} =
-  self.elements[row]
+proc elements*(self: Basis): array[3, Vector3] {.inline.} =
+ godot_basis_get_elements(self, result)
 
-proc setRow*(self: var Basis; row: range[0..2]; value: Vector3) {.inline.} =
-  self.elements[row] = value
-
-proc getMainDiagonal*(self: Basis): Vector3 {.inline.} =
-  vec3(self.elements[0][0], self.elements[1][1], self.elements[2][2])
-
-proc zero*(self: var Basis) {.inline.} =
-  self.elements[0].zero()
-  self.elements[1].zero()
-  self.elements[2].zero()
-
-proc orthonormalize(self: var Basis) =
-  var x = self.axis(0)
-  var y = self.axis(1)
-  var z = self.axis(2)
-
-  x.normalize()
-  y = y - x * x.dot(y)
-  y.normalize()
-  z = z - x * x.dot(z) - y * y.dot(z)
-  z.normalize()
-
-  self.setAxis(0, x)
-  self.setAxis(1, y)
-  self.setAxis(2, z)
-
-proc orthonormalized*(self: Basis): Basis {.inline.} =
-  result = self
-  result.orthonormalize()
-
-proc transpose*(self: var Basis) {.inline.} =
-  swap(self.elements[0].x, self.elements[1].x)
-  swap(self.elements[0].z, self.elements[2].x)
-  swap(self.elements[1].z, self.elements[2].y)
-
-proc transposed*(self: Basis): Basis {.inline.} =
-  result = self
-  result.transpose()
-
-proc isOrthogonal*(self: Basis): bool {.inline.} =
-  let id = initBasis()
-  let m = self * self.transposed()
-  result = id.isEqualApprox(m)
-
-proc isRotation*(self: Basis): bool {.inline.} =
-  self.determinant().isEqualApprox(1.0) and self.isOrthogonal()
-
-proc isSymmetric*(self: Basis): bool {.inline.} =
-  if not self.elements[0][1].isEqualApprox(self.elements[1][0]):
-    return false
-  if not self.elements[0][2].isEqualApprox(self.elements[2][0]):
-    return false
-  if not self.elements[1][2].isEqualApprox(self.elements[2][1]):
-    return false
-  result = true
-
-proc scale*(self: var Basis, scale: Vector3) =
-  self[0].x *= scale.x
-  self[0].y *= scale.x
-  self[0].z *= scale.x
-  self[1].x *= scale.y
-  self[1].y *= scale.y
-  self[1].z *= scale.y
-  self[2].x *= scale.z
-  self[2].y *= scale.z
-  self[2].z *= scale.z
-
-proc scaled*(self: Basis, scale: Vector3): Basis =
-  result = self
-  result.scale(scale)
-
-proc rotated*(self: Basis; axis: Vector3; phi: float32): Basis {.inline.} =
-  initBasis(axis, phi) * self
-
-proc rotate*(self: var Basis; axis: Vector3; phi: float32) {.inline.} =
-  self = self.rotated(axis, phi)
-
-proc rotated*(self: Basis; euler: Vector3): Basis {.inline.} =
-  initBasis(euler) * self
-
-proc rotate*(self: var Basis; euler: Vector3) {.inline.} =
-  self = self.rotated(euler)
-
-proc getScale*(self: Basis): Vector3 =
-  let detSign = if self.determinant() > 0: 1'f32 else: -1'f32
-  result = detSign * vec3(
-    vec3(self.elements[0].x, self.elements[1].x, self.elements[2].x).length(),
-    vec3(self.elements[0].y, self.elements[1].y, self.elements[2].y).length(),
-    vec3(self.elements[0].z, self.elements[1].z, self.elements[2].z).length(),
-  )
-
-proc getRotation*(self: Basis): Vector3 {.inline.} =
-  var m = self.orthonormalized()
-  let det = m.determinant()
-  if det < 0:
-    m.scale(vec3(-1, -1, -1))
-  result = m.getEuler()
-
-proc setScale*(self: var Basis; scale: Vector3) =
-  let e = self.getEuler()
-  self = initBasis() # reset to identity
-  self.scale(scale)
-  self.rotate(e)
-
-proc setRotationEuler*(self: var Basis; euler: Vector3) =
-  let s = self.getScale()
-  self = initBasis()
-  self.scale(s)
-  self.rotate(euler)
-
-proc setRotationAxisAngle*(self: var Basis; axis: Vector3; angle: float32) =
-  let s = self.getScale()
-  self = initBasis()
-  self.scale(s)
-  self.rotate(axis, angle)
-
-proc asQuat*(self: Basis): Quat =
-  let trace = self.elements[0].x + self.elements[1].y + self.elements[2].z
-  var temp: array[4, float32]
-  if trace > 0'f32:
-    var s = sqrt(trace + 1.0)
-    temp[3] = s * 0.5
-    s = 0.5 / s
-
-    temp[0] = (self.elements[2].y - self.elements[1].z) * s
-    temp[1] = (self.elements[0].z - self.elements[2].x) * s
-    temp[2] = (self.elements[1].x - self.elements[0].y) * s
-  else:
-    let i = if self.elements[0].x < self.elements[1].y:
-              if self.elements[1].y < self.elements[2].z: 2 else: 1
-            else:
-              if self.elements[0].x < self.elements[2].z: 2 else: 0
-    let j = (i + 1) mod 3
-    let k = (i + 2) mod 3
-
-    var s = sqrt(self.elements[i][i] - self.elements[j][j] -
-                 self.elements[k][k] + 1.0)
-    temp[i] = s * 0.5
-    s = 0.5 / s
-
-    temp[3] = (self.elements[k][j] - self.elements[j][k]) * s
-    temp[j] = (self.elements[j][i] + self.elements[i][j]) * s
-    temp[k] = (self.elements[k][i] + self.elements[i][k]) * s
-
-  result = initQuat(temp[0], temp[1], temp[2], temp[3])
-
-proc xform*(self: Basis; v: Vector3): Vector3 {.inline.} =
-  vec3(
-    self.elements[0].dot(v),
-    self.elements[1].dot(v),
-    self.elements[2].dot(v)
-  )
-
-proc xformInv*(self: Basis; v: Vector3): Vector3 {.inline.} =
-  vec3(
-    self.elements[0].x * v.x + self.elements[1].x * v.y + self.elements[2].x * v.z,
-    self.elements[0].y * v.x + self.elements[1].y * v.y + self.elements[2].y * v.z,
-    self.elements[0].z * v.x + self.elements[1].z * v.y + self.elements[2].z * v.z,
-  )
-
-const orthoBases = [
-  initBasis(1, 0, 0, 0, 1, 0, 0, 0, 1),
-  initBasis(0, -1, 0, 1, 0, 0, 0, 0, 1),
-  initBasis(-1, 0, 0, 0, -1, 0, 0, 0, 1),
-  initBasis(0, 1, 0, -1, 0, 0, 0, 0, 1),
-  initBasis(1, 0, 0, 0, 0, -1, 0, 1, 0),
-  initBasis(0, 0, 1, 1, 0, 0, 0, 1, 0),
-  initBasis(-1, 0, 0, 0, 0, 1, 0, 1, 0),
-  initBasis(0, 0, -1, -1, 0, 0, 0, 1, 0),
-  initBasis(1, 0, 0, 0, -1, 0, 0, 0, -1),
-  initBasis(0, 1, 0, 1, 0, 0, 0, 0, -1),
-  initBasis(-1, 0, 0, 0, 1, 0, 0, 0, -1),
-  initBasis(0, -1, 0, -1, 0, 0, 0, 0, -1),
-  initBasis(1, 0, 0, 0, 0, 1, 0, -1, 0),
-  initBasis(0, 0, -1, 1, 0, 0, 0, -1, 0),
-  initBasis(-1, 0, 0, 0, 0, -1, 0, -1, 0),
-  initBasis(0, 0, 1, -1, 0, 0, 0, -1, 0),
-  initBasis(0, 0, 1, 0, 1, 0, -1, 0, 0),
-  initBasis(0, -1, 0, 0, 0, 1, -1, 0, 0),
-  initBasis(0, 0, -1, 0, -1, 0, -1, 0, 0),
-  initBasis(0, 1, 0, 0, 0, -1, -1, 0, 0),
-  initBasis(0, 0, 1, 0, -1, 0, 1, 0, 0),
-  initBasis(0, 1, 0, 0, 0, 1, 1, 0, 0),
-  initBasis(0, 0, -1, 0, 1, 0, 1, 0, 0),
-  initBasis(0, -1, 0, 0, 0, -1, 1, 0, 0)
-]
-
-proc orthogonalIndex*(self: Basis): int =
-  var orth = self
-  for i in 0..2:
-    for j in 0..2:
-      var v = orth[i][j]
-      if v > 0.5:
-        v = 1.0'f32
-      elif v < -0.5:
-        v = -1.0'f32
-      else:
-        v = 0'f32
-      orth[i][j] = v
-
-  for idx, base in orthoBases:
-    if base == orth:
-      return idx
-
-proc setOrthogonalIndex*(self: var Basis, idx: range[0..23]) =
-  self = orthoBases[idx]
-
-proc rotate*(self: var Vector3; axis: Vector3; phi: float32) =
-  self = initBasis(axis, phi).xform(self)
-
-proc rotated*(self: Vector3; axis: Vector3; phi: float32): Vector3 =
-  result = self
-  result.rotate(axis, phi)
-
-{.pop.} # stackTrace: off
+proc `[]`*(self: Basis; axis: range[0..2]): Vector3 {.
+    noSideEffect,
+    importc: "godot_basis_get_axis", header: "godot/basis.h".}
+proc `[]=`*(self: var Basis; axis: range[0..2];
+            value: Vector3) {.
+    noSideEffect,
+    importc: "godot_basis_set_axis", header: "godot/basis.h".}
+proc row*(self: Basis; row: cint): Vector3 {.
+    noSideEffect,
+    importc: "godot_basis_get_row", header: "godot/basis.h".}
+proc setRow*(self: var Basis; row: cint;
+             value: Vector3) {.
+    noSideEffect,
+    importc: "godot_basis_set_row", header: "godot/basis.h".}
+proc `==`*(self: Basis; b: Basis): bool {.
+    noSideEffect,
+    importc: "godot_basis_operator_equal", header: "godot/basis.h".}
+proc `+`*(self: Basis; b: Basis): Basis {.
+    noSideEffect,
+    importc: "godot_basis_operator_add", header: "godot/basis.h".}
+proc `-`*(self: Basis; b: Basis): Basis {.
+    noSideEffect,
+    importc: "godot_basis_operator_substract", header: "godot/basis.h".}
+proc `*`*(self: Basis; b: Basis): Basis {.
+    noSideEffect,
+    importc: "godot_basis_operator_multiply_vector", header: "godot/basis.h".}
+proc `*`*(self: Basis; b: float32): Basis {.
+    noSideEffect,
+    importc: "godot_basis_operator_multiply_scalar", header: "godot/basis.h".}

godot/core/color.nim

@@ -0,0 +1,76 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase, strings
+
+type
+  Color* {.importc: "godot_color", header: "godot/color.h", byref.} = object
+
+proc initColor(dest: var Color; r, g, b, a: float32) {.
+    importc: "godot_color_new_rgba", header: "godot/color.h".}
+proc initColor(dest: var Color; r, g, b: float32) {.
+    importc: "godot_color_new_rgb",
+    header: "godot/color.h".}
+
+proc initColor*(r, g, b, a: float32): Color {.inline.} =
+  initColor(result, r, g, b, a)
+
+proc initColor*(r, g, b: float32): Color {.inline.} =
+  initColor(result, r, g, b)
+
+proc r*(self: Color): float32 {.
+    importc: "godot_color_get_r", header: "godot/color.h".}
+proc `r=`*(self: var Color; r: float32) {.
+    importc: "godot_color_set_r", header: "godot/color.h".}
+proc g*(self: Color): float32 {.
+    importc: "godot_color_get_g", header: "godot/color.h".}
+proc `g=`*(self: var Color; g: float32) {.
+    importc: "godot_color_set_g", header: "godot/color.h".}
+proc b*(self: Color): float32 {.
+    importc: "godot_color_get_b", header: "godot/color.h".}
+proc `b=`*(self: var Color; b: float32) {.
+    importc: "godot_color_set_b", header: "godot/color.h".}
+proc a*(self: Color): float32 {.
+    importc: "godot_color_get_a", header: "godot/color.h".}
+proc `a=`*(self: var Color; a: float32) {.
+    importc: "godot_color_set_a", header: "godot/color.h".}
+
+proc h*(self: Color): float32 {.
+    importc: "godot_color_get_h", header: "godot/color.h".}
+proc s*(self: Color): float32 {.
+    importc: "godot_color_get_s", header: "godot/color.h".}
+proc v*(self: Color): float32 {.
+    importc: "godot_color_get_v", header: "godot/color.h".}
+
+proc toGodotString*(self: Color): GodotString {.
+    importc: "godot_color_as_string", header: "godot/color.h".}
+proc `$`*(self: Color): string {.inline.} =
+  $self.toGodotString()
+
+proc toHtml*(self: Color; with_alpha: bool): GodotString {.
+    importc: "godot_color_to_html", header: "godot/color.h".}
+
+proc to32CInt(self: Color): cint {.
+    importc: "godot_color_to_32", header: "godot/color.h".}
+proc toARGB32CInt(self: Color): cint {.
+    importc: "godot_color_to_ARGB32", header: "godot/color.h".}
+
+proc to32*(self: Color): uint32 {.inline.}=
+  cast[uint32](to32CInt(self))
+proc toARGB32*(self: Color): uint32 {.inline.} =
+  cast[uint32](toARGB32CInt(self))
+
+proc gray*(self: Color): float32 {.
+    importc: "godot_color_gray", header: "godot/color.h".}
+proc inverted*(self: Color): Color {.
+    importc: "godot_color_inverted", header: "godot/color.h".}
+proc contrasted*(self: Color): Color {.
+    importc: "godot_color_contrasted", header: "godot/color.h".}
+proc lerp*(self: Color; b: Color; t: float32): Color {.
+    importc: "godot_color_linear_interpolate", header: "godot/color.h".}
+proc blend*(self: Color; over: Color): Color {.
+    importc: "godot_color_blend", header: "godot/color.h".}
+
+proc `==`*(self, b: Color): bool {.
+    importc: "godot_color_operator_equal", header: "godot/color.h".}
+proc `<`*(self, b: Color): bool {.
+    importc: "godot_color_operator_less", header: "godot/color.h".}

godot/core/colors.nim

@@ -1,88 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import hashes
-
-import godotcoretypes, gdnativeapi
-
-proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} =
-  Color(
-    r: r,
-    g: g,
-    b: b,
-    a: a
-  )
-
-proc initColor*(): Color {.inline.} =
-  ## Initializes black color with 1.0 alpha
-  initColor(0, 0, 0)
-
-proc h*(self: Color): float32 {.inline.} =
-  getGDNativeAPI().colorGetH(self)
-
-proc s*(self: Color): float32 {.inline.} =
-  getGDNativeAPI().colorGetS(self)
-
-proc v*(self: Color): float32 {.inline.} =
-  getGDNativeAPI().colorGetV(self)
-
-proc `$`*(self: Color): string {.inline.} =
-  result = newStringOfCap(50)
-  result.add($self.r)
-  result.add(", ")
-  result.add($self.g)
-  result.add(", ")
-  result.add($self.b)
-  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]
-  for i, num in nums:
-    target[targetIdx + i] = if num < 10: chr(ord('0') + num)
-                            else: chr(ord('A') + (num - 10))
-
-proc toHtml*(self: Color, withAlpha: bool): string =
-  let size = if withAlpha: 8 else: 6
-  result = newString(size)
-  toHex(self.r, result, 0)
-  toHex(self.g, result, 2)
-  toHex(self.b, result, 4)
-  if withAlpha:
-    toHex(self.b, result, 6)
-
-proc toARGB32*(self: Color): uint32 {.inline.} =
-  result = uint8(self.a * 255)
-  result = (result shl 8) or uint8(self.r * 255)
-  result = (result shl 8) or uint8(self.g * 255)
-  result = (result shl 8) or uint8(self.b * 255)
-
-proc gray*(self: Color): float32 {.inline.} =
-  getGDNativeAPI().colorGray(self)
-
-proc inverted*(self: Color): Color {.inline.} =
-  getGDNativeAPI().colorInverted(self).toColor()
-
-proc contrasted*(self: Color): Color {.inline.} =
-  getGDNativeAPI().colorContrasted(self).toColor()
-
-proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} =
-  getGDNativeAPI().colorLinearInterpolate(self, b, t).toColor()
-
-proc blend*(self: Color; over: Color): Color {.inline.} =
-  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
-
-proc `<`*(a, b: Color): bool =
-  if a.r == b.r:
-    if a.g == b.g:
-      if a.b == b.b:
-        return a.a < b.a
-      return a.b < b.b
-    return a.g < b.g
-  return a.r < b.r

godot/core/dictionaries.nim

@@ -1,110 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import hashes
-import internal/godotinternaltypes, internal/godotdictionaries,
-       internal/godotvariants, internal/godotstrings
-
-type
-  Dictionary* = ref object
-    godotDictionary: GodotDictionary
-
-proc dictionaryFinalizer(dict: Dictionary) =
-  dict.godotDictionary.deinit()
-
-proc newDictionary*(): Dictionary {.inline.} =
-  new(result, dictionaryFinalizer)
-  initGodotDictionary(result.godotDictionary)
-
-proc newDictionary*(dict: GodotDictionary): Dictionary {.inline.} =
-  new(result, dictionaryFinalizer)
-  result.godotDictionary = dict
-
-proc godotDictionary*(dict: Dictionary): ptr GodotDictionary =
-  ## WARNING: do not keep the returned value for longer than the lifetime of
-  ## ``dict``
-  addr dict.godotDictionary
-
-proc len*(self: Dictionary): int {.inline.} =
-  self.godotDictionary.len.int
-
-proc isEmpty*(self: Dictionary): bool {.inline.} =
-  self.godotDictionary.isEmpty()
-
-proc clear*(self: Dictionary) {.inline.} =
-  self.godotDictionary.clear()
-
-proc hash*(self: Dictionary): Hash {.inline.} =
-  hash(self.godotDictionary.godotHash())
-
-import variants, arrays
-
-proc newVariant*(dict: Dictionary): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant[], dict.godotDictionary)
-
-proc asDictionary*(self: Variant): Dictionary {.inline.} =
-  newDictionary(self.godotVariant[].asGodotDictionary())
-
-proc contains*(self: Dictionary; key: Variant): bool {.inline.}=
-  self.godotDictionary.contains(key.godotVariant[])
-
-proc contains*(self: Dictionary; keys: Array): bool {.inline.} =
-  self.godotDictionary.contains(keys.godotArray[])
-
-proc del*(self: Dictionary; key: Variant) {.inline.} =
-  self.godotDictionary.del(key.godotVariant[])
-
-proc keys*(self: Dictionary): Array {.inline.} =
-  newArray(self.godotDictionary.keys())
-
-proc values*(self: Dictionary): Array {.inline.} =
-  newArray(self.godotDictionary.values())
-
-proc `[]`*(self: Dictionary; key: Variant): Variant {.inline.} =
-  newVariant(self.godotDictionary[key.godotVariant[]])
-
-proc `[]`*(self: Dictionary; keyStr: string): Variant {.inline.} =
-  var godotVariant: GodotVariant
-  var godotStr = keyStr.toGodotString()
-  initGodotVariant(godotVariant, godotStr)
-  result = newVariant(self.godotDictionary[godotVariant])
-  godotStr.deinit()
-  godotVariant.deinit()
-
-proc `[]=`*(self: Dictionary; key, value: Variant) {.inline.} =
-  self.godotDictionary[key.godotVariant[]] = value.godotVariant[]
-
-proc `==`*(self, other: Dictionary): bool {.inline.} =
-  if self.isNil and other.isNil: return true
-  if self.isNil != other.isNil: return false
-  result = self.godotDictionary == other.godotDictionary
-
-proc toJson*(self: Dictionary): string {.inline.} =
-  var s = self.godotDictionary.toJson()
-  result = $s
-  s.deinit()
-
-iterator keys*(dict: Dictionary): Variant =
-  let keyArr = dict.keys()
-  for key in keyArr:
-    yield key
-
-iterator values*(dict: Dictionary): Variant =
-  let valArr = dict.values()
-  for val in valArr:
-    yield val
-
-iterator pairs*(dict: Dictionary): tuple[key, val: Variant] =
-  for key in keys(dict):
-    yield (key, dict[key])
-
-proc `$`*(self: Dictionary): string =
-  result = newStringOfCap(32)
-  result.add('{')
-  for k, v in self:
-    if result.len > 1:
-      result.add(", ")
-    result.add($k)
-    result.add(": ")
-    result.add($v)
-  result.add('}')

godot/core/dictionary.nim

@@ -0,0 +1,96 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import hashes
+import godotbase, arrays, variant, strings
+
+type
+  Dictionary* {.importc: "godot_dictionary",
+                header: "godot/dictionary.h", byref.} = object
+
+proc initVariant(dest: var Variant; dict: Dictionary) {.
+    importc: "godot_variant_new_dictionary",
+    header: "godot/variant.h".}
+
+proc variant*(dict: Dictionary): Variant {.inline.} =
+  initVariant(result, dict)
+
+proc asDictionary*(self: Variant): Dictionary {.
+    importc: "godot_variant_as_dictionary", header: "godot/variant.h".}
+
+proc initDictionary(dest: var Dictionary;
+                    src: Dictionary) {.
+    importc: "godot_dictionary_new_copy",
+    header: "godot/dictionary.h".}
+
+proc deinit(self: var Dictionary) {.
+    importc: "godot_dictionary_destroy", header: "godot/dictionary.h".}
+
+proc `=`(self: var Dictionary, other: Dictionary) {.inline.} =
+  initDictionary(self, other)
+
+proc `=destroy`(self: Dictionary) {.inline.} =
+  unsafeAddr(self)[].deinit()
+
+proc initDictionary(dest: var Dictionary) {.
+    importc: "godot_dictionary_new", header: "godot/dictionary.h".}
+proc initDictionary*(): Dictionary {.inline.} =
+  initDictionary(result)
+
+proc len*(self: Dictionary): cint {.
+    importc: "godot_dictionary_size", header: "godot/dictionary.h".}
+proc isEmpty*(self: Dictionary): bool {.
+    importc: "godot_dictionary_empty", header: "godot/dictionary.h".}
+proc clear*(self: var Dictionary) {.
+    importc: "godot_dictionary_clear", header: "godot/dictionary.h".}
+proc contains*(self: Dictionary; key: Variant): bool {.
+    importc: "godot_dictionary_has",
+    header: "godot/dictionary.h".}
+proc contains*(self: Dictionary; keys: Array): bool {.
+    importc: "godot_dictionary_has_all",
+    header: "godot/dictionary.h".}
+proc del*(self: var Dictionary; key: Variant) {.
+    importc: "godot_dictionary_erase", header: "godot/dictionary.h".}
+
+proc godotHash*(self: Dictionary): cint {.
+    importc: "godot_dictionary_hash", header: "godot/dictionary.h".}
+proc hash*(self: Dictionary): Hash {.inline.} =
+  hash(godotHash(self))
+
+proc keys*(self: Dictionary): Array {.
+    importc: "godot_dictionary_keys", header: "godot/dictionary.h".}
+proc values*(self: Dictionary): Array {.
+    importc: "godot_dictionary_values", header: "godot/dictionary.h".}
+proc `[]`*(self: Dictionary; key: Variant): Variant {.
+    importc: "godot_dictionary_get", header: "godot/dictionary.h".}
+
+proc `[]`*(self: Dictionary; keyStr: string): Variant =
+  let key = variant(keyStr)
+  result = self[key]
+
+proc `[]=`*(self: var Dictionary; key, value: Variant) {.
+    importc: "godot_dictionary_set",
+    header: "godot/dictionary.h".}
+proc mget*(self: var Dictionary; key: Variant): ptr Variant {.
+    importc: "godot_dictionary_operator_index",
+    header: "godot/dictionary.h".}
+
+proc `==`*(self, other: Dictionary): bool {.
+    importc: "godot_dictionary_operator_equal",
+    header: "godot/dictionary.h".}
+
+proc toJson*(self: Dictionary): GodotString {.
+    importc: "godot_dictionary_to_json", header: "godot/dictionary.h".}
+
+iterator keys*(dict: Dictionary): Variant =
+  let keyArr = dict.keys()
+  for key in keyArr:
+    yield key
+
+iterator values*(dict: Dictionary): Variant =
+  let valArr = dict.values()
+  for val in valArr:
+    yield val
+
+iterator pairs*(dict: Dictionary): tuple[key, val: Variant] =
+  for key in keys(dict):
+    yield (key, dict[key])

godot/core/godotbase.nim

@@ -1,64 +1,107 @@
-# Copyright (c) 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
-import math, godotinternal
+type
+  Error* {.importc: "godot_error", header: "godot/gdnative.h",
+           size: sizeof(cint), pure.} = enum
+    OK,
+    Failed,    ## Generic fail error
+    Unavailable,    ## What is requested is unsupported/unavailable
+    Unconfigured,   ## The object being used hasnt been properly set up yet
+    Unauthorized,   ## Missing credentials for requested resource
+    ParameterRangeError, ## Parameter given out of range (5)
+    OutOfMemory,  ## Out of memory
+    FileNotFound,
+    FileBadDrive,
+    FileBadPath,
+    FileNoPermission, ##  (10)
+    FileAlreadyInUse,
+    FileCantOpen,
+    FileCantWrite,
+    FileCantRead,
+    FileUnrecognized, ##  (15)
+    FileCorrupt,
+    FileMissingDependencies,
+    FileEOF,
+    CantOpen, ## Can't open a resource/socket/file
+    CantCreate,    ##  (20)
+    QueryFailed,
+    AlreadyInUse,
+    Locked, ## resource is locked
+    Timeout,
+    CantConnect, ##  (25)
+    CantResolve,
+    ConnectionError,
+    CantAquireResource,
+    CantFork,
+    InvalidData, ## Data passed is invalid	(30)
+    InvalidParameter, ## Parameter passed is invalid
+    AlreadyExists, ## When adding, item already exists
+    DoesNotExist, ## When retrieving/erasing, it item does not exist
+    DatabaseCantRead, ## Database is full
+    DatabaseCantWrite, ## Database is full	(35)
+    CompilationFailed,
+    MethodNotFound,
+    LinkFailed,
+    ScriptFailed,
+    CyclicLink, ##  (40)
+    InvalidDeclaration,
+    DuplicateSymbol,
+    PauseError,
+    Busy,
+    Skip, ##  (45)
+    Help,           ## user requested help!!
+    Bug,
+      ## a bug in the software certainly happened, due to a double
+      ## check failing or unexpected behavior.
+    PrinterOnFire, ## the parallel port printer is engulfed in flames
+    WTF ## shit happens, has never been used, though
 
-# math helpers
+const MAX_ARG_COUNT* = 128
 
-{.push stackTrace: off.}
-const EPSILON = 0.00001'f32
-proc isEqualApprox*(a, b: float32): bool {.inline, noinit.}  =
-  abs(a - b) < EPSILON
+type
+  GodotObject* {.importc: "godot_object", header: "godot/gdnative.h".} = object
+  Array* {.importc: "godot_array", header: "godot/array.h", byref.} = object
+  Variant* {.importc: "godot_variant",
+             header: "godot/variant.h", byref.} = object
 
-proc isEqualApprox*(a, b: float64): bool {.inline, noinit.} =
-  abs(a - b) < EPSILON
+proc initArray(dest: var Array, src: Array) {.
+    importc: "godot_array_new_copy",
+    header: "godot/array.h".}
 
-proc sign*(a: float32): float32 {.inline, noinit.} =
-  if a < 0: -1.0'f32 else: 1.0'f32
+proc deinit(self: var Array) {.importc: "godot_array_destroy",
+    header: "godot/array.h".}
 
-proc sign*(a: float64): float64 {.inline, noinit.} =
-  if a < 0: -1.0'f64 else: 1.0'f64
+proc `=`(self: var Array, other: Array) {.inline.} =
+  initArray(self, other)
 
-proc stepify*(value, step: float64): float64 {.inline, noinit.} =
-  if step != 0'f64:
-    floor(value / step + 0.5'f64) * step
-  else:
-    value
+proc `=destroy`(self: Array) {.inline.} =
+  unsafeAddr(self).deinit()
 
-proc stepify*(value, step: float32): float32 {.inline, noinit.} =
-  if step != 0'f32:
-    floor(value / step + 0.5'f32) * step
-  else:
-    value
+proc initVariant(dest: var Variant; src: Variant) {.
+    importc: "godot_variant_new_copy", header: "godot/variant.h".}
 
-when (NimMajor, NimMinor, NimPatch) < (0, 20, 4):
-  # Newer Nim has these procs in system module
+proc deinit*(self: var Variant) {.
+    importc: "godot_variant_destroy", header: "godot/variant.h".}
 
-  proc min*(x, y: float32): float32 {.inline, noinit.} =
-    if x <= y: x else: y
+proc `=`(self: var Variant, other: Variant) {.inline.} =
+  initVariant(self, other)
 
-  proc abs*(x: float32): float32 {.inline, noinit.} =
-    if x < 0.0: -x else: x
+proc `=destroy`(self: Variant) {.inline.} =
+  unsafeAddr(self).deinit()
 
-  proc max*(x, y: float32): float32 {.inline, noinit.} =
-    if y <= x: x else: y
+# System Functions
 
-{.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()
+proc godotAlloc*(bytes: cint): pointer {.
+  importc: "godot_alloc", header: "godot/gdnative.h".}
+  ## Allocates the specified number of bytes.
+  ## Using this instead of stdlib proc will help Godot track how much memory
+  ## is in use in debug mode.
+proc godotRealloc*(p: pointer; bytes: cint): pointer {.
+  importc: "godot_realloc", header: "godot/gdnative.h".}
+  ## Reallocates the pointer for the specified number of bytes.
+  ## Using this instead of stdlib proc will help Godot track how much memory
+  ## is in use in debug mode.
+proc godotFree*(p: pointer) {.importc: "godot_free", header: "godot/gdnative.h".}
+  ## Frees the memory pointed to by the pointer.
+  ## Using this instead of stdlib proc will help Godot track how much memory
+  ## is in use in debug mode.

godot/core/godotcore.nim

@@ -0,0 +1,298 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase
+import strings, vector2, rect2, vector3, transform2d, plane, quat
+import rect3, basis, transform, color, nodepath, rid
+import dictionary, arrays, poolarray, variant
+
+export godotbase, strings, vector2, rect2, vector3, transform2d, plane, quat,
+       rect3, basis, transform, color, nodepath, rid, dictionary, arrays,
+       poolarray, variant
+
+# MethodBind API
+
+type
+  GodotMethodBind* {.importc: "godot_method_bind",
+                     header: "godot/gdnative.h".} = object
+
+proc getMethod*(className: cstring; methodName: cstring): ptr GodotMethodBind {.
+    importc: "godot_method_bind_get_method", header: "godot/gdnative.h".}
+proc ptrCall*(methodBind: ptr GodotMethodBind;
+              instance: ptr GodotObject;
+              args: ptr array[MAX_ARG_COUNT, pointer];
+              ret: pointer) {.
+    importc: "godot_method_bind_ptrcall", header: "godot/gdnative.h".}
+proc call*(methodBind: ptr GodotMethodBind;
+           instance: ptr GodotObject;
+           args: ptr array[MAX_ARG_COUNT, Variant]; argCount: cint;
+           callError: var VariantCallError): Variant {.
+    importc: "godot_method_bind_call", header: "godot/gdnative.h".}
+
+# Script API
+
+type
+  GodotNativeInitOptions* {.importc: "godot_gdnative_init_options",
+                            header: "godot/gdnative.h".} = object
+    inEditor* {.importc: "in_editor".}: bool
+    coreApiHash* {.importc: "core_api_hash".}: uint64
+    editorApiHash* {.importc: "editor_api_hash".}: uint64
+    noApiHash* {.importc: "no_api_hash".}: uint64
+
+  GodotNativeTerminateOptions* {.importc: "godot_gdnative_terminate_options",
+                                 header: "godot/gdnative.h".} = object
+    inEditor* {.importc: "in_editor".}: bool
+
+  GodotMethodRPCMode* {.importc: "godot_method_rpc_mode",
+                        header: "godot_nativescript.h",
+                        size: sizeof(cint), pure.} = enum
+    Disabled,
+    Remote,
+    Sync,
+    Master,
+    Slave
+
+  GodotMethodAttributes* {.importc: "godot_method_attributes",
+                           header: "godot_nativescript.h".} = object
+    rpcMode* {.importc: "rpc_type".}: GodotMethodRPCMode
+
+  GodotPropertyHint* {.importc: "godot_property_hint",
+                       header: "godot_nativescript.h",
+                       size: sizeof(cint), pure.} = enum
+    None, ## no hint provided.
+    Range, ## hint_text = "min,max,step,slider; // slider is optional"
+    ExpRange, ## hint_text = "min,max,step", exponential edit
+    Enum, ## hint_text= "val1,val2,val3,etc"
+    ExpEasing, ## exponential easing funciton (Math::ease)
+    Length, ## hint_text= "length" (as integer)
+    SpriteFrame,
+    KeyAccel, ## hint_text= "length" (as integer)
+    Flags, ##  hint_text= "flag1,flag2,etc" (as bit flags)
+    Layers2DRender,
+    Layers2DPhysics,
+    Layers3DRender,
+    Layers3DPhysics,
+    File, ## a file path must be passed, hint_text (optionally)
+          ## is a filter "*.png,*.wav,*.doc,"
+    Dir,  ## a directort path must be passed
+    GlobalFile, ## a file path must be passed, hint_text (optionally) is a
+                ## filter "*.png,*.wav,*.doc,"
+    GlobalDir, ## a directort path must be passed
+    ResourceType, ## a resource object type
+    MultilineText, ## used for string properties that can contain multiple lines
+    ColorNoAlpha, ## used for ignoring alpha component when editing a color
+    ImageCompressLossy,
+    ImageCompressLossless,
+    ObjectId,
+    TypeString, ## a type string, the hint is the base type to choose
+    NodePathToEditedNode, ## so something else can provide this
+                          ## (used in scripts)
+    MethodOfVariantType, ## a method of a type
+    MethodOfBaseType, ## a method of a base type
+    MethodOfInstance, ## a method of an instance
+    MethodOfScript, ## a method of a script & base
+    PropertyOfVariantType, ## a property of a type
+    PropertyOfBaseType, ## a property of a base type
+    PropertyOfInstance, ## a property of an instance
+    PropertyOfScript, ## a property of a script & base
+    PropertyHintMax
+
+const
+  GODOT_PROPERTY_USAGE_STORAGE_VALUE = 1.cint
+  GODOT_PROPERTY_USAGE_EDITOR_VALUE = 2.cint
+  GODOT_PROPERTY_USAGE_NETWORK_VALUE = 4.cint
+  GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE = 8.cint
+  GODOT_PROPERTY_USAGE_CHECKABLE_VALUE = 16.cint
+  GODOT_PROPERTY_USAGE_CHECKED_VALUE = 32.cint
+  GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE = 64.cint
+  GODOT_PROPERTY_USAGE_GROUP_VALUE = 128.cint
+  GODOT_PROPERTY_USAGE_CATEGORY_VALUE = 256.cint
+  GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE = 512.cint
+  GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE = 1024.cint
+  GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE = 2048.cint
+  GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE = 4096.cint
+  GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE = 8192.cint
+  GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE = 16384.cint
+  GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE = 32768.cint
+  GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE = 65536.cint
+
+  GODOT_PROPERTY_USAGE_DEFAULT_VALUE: cint =
+      GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_EDITOR_VALUE or
+      GODOT_PROPERTY_USAGE_NETWORK_VALUE
+  GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE: cint =
+      GODOT_PROPERTY_USAGE_STORAGE_VALUE or
+      GODOT_PROPERTY_USAGE_EDITOR_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE or
+      GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
+  GODOT_PROPERTY_USAGE_NOEDITOR_VALUE: cint =
+      GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE
+
+type
+  GodotPropertyUsageFlags* {.importc: "godot_property_usage_flags",
+                             header: "godot_nativescript.h", size: sizeof(cint),
+                             pure.} = enum
+    Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE
+    Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE
+    Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE
+    NoEditor = GODOT_PROPERTY_USAGE_NOEDITOR_VALUE
+    Default = GODOT_PROPERTY_USAGE_DEFAULT_VALUE
+    EditorHelper = GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE
+    Checkable = GODOT_PROPERTY_USAGE_CHECKABLE_VALUE
+      ## used for editing global variables
+    Checked = GODOT_PROPERTY_USAGE_CHECKED_VALUE
+      ## used for editing global variables
+    Internationalized = GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
+      ## hint for internationalized strings
+    DefaultIntl = GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE
+    Group = GODOT_PROPERTY_USAGE_GROUP_VALUE
+      ## used for grouping props in the editor
+    Category = GODOT_PROPERTY_USAGE_CATEGORY_VALUE
+    NonZero = GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE
+      ## only store if nonzero
+    NonOne = GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE
+      ## only store if false
+    NoInstanceState = GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE
+    RestartIfChanged = GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE
+    ScriptVariable = GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE
+    StoreIfNull = GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE
+    AnimateAsTrigger = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE
+    UpdateAllIfModified = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE
+
+  GodotPropertyAttributes* {.importc: "godot_property_attributes",
+                             header: "godot_nativescript.h", bycopy.} = object
+    rsetType* {.importc: "rset_type".}: GodotMethodRPCMode
+    typ* {.importc: "type".}: cint
+    hint* {.importc: "hint".}: GodotPropertyHint
+    hintString* {.importc: "hint_string".}: GodotString
+    usage* {.importc: "usage".}: GodotPropertyUsageFlags
+    defaultValue* {.importc: "default_value".}: Variant
+
+  GodotInstanceCreateFunc* {.importc: "godot_instance_create_func",
+                             header: "godot_nativescript.h", bycopy.} = object
+    createFunc* {.importc: "create_func".}:
+      proc (obj: ptr GodotObject; methodData: pointer): pointer {.noconv.}
+        ## returns user data
+    methodData* {.importc: "method_data".}: pointer
+    freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.}
+
+  GodotInstanceDestroyFunc* {.importc: "godot_instance_destroy_func",
+                              header: "godot_nativescript.h", bycopy.} = object
+    destroyFunc* {.importc: "destroy_func".}:
+      proc (obj: ptr GodotObject; methodData: pointer;
+            userData: pointer) {.noconv.}
+    methodData* {.importc: "method_data".}: pointer
+    freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.}
+
+proc godotScriptRegisterClass*(libHandle: pointer; name, base: cstring;
+                               create_func: GodotInstanceCreateFunc;
+                               destroy_func: GodotInstanceDestroyFunc) {.
+    importc: "godot_nativescript_register_class",
+    header: "godot_nativescript.h".}
+proc godotScriptRegisterToolClass*(libHandle: pointer; name, base: cstring;
+                                   createFunc: GodotInstanceCreateFunc;
+                                   destroyFunc: GodotInstanceDestroyFunc) {.
+    importc: "godot_nativescript_register_tool_class",
+    header: "godot_nativescript.h".}
+type
+  GodotInstanceMethod* {.importc: "godot_instance_method",
+                         header: "godot_nativescript.h", bycopy.} = object
+    meth* {.importc: "method".}:
+      proc (obj: ptr GodotObject; methodData: pointer;
+            userData: pointer; numArgs: cint;
+            args: var ptr array[MAX_ARG_COUNT, Variant]): Variant {.noconv.}
+    methodData* {.importc: "method_data".}: pointer
+    freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.}
+
+proc godotScriptRegisterMethod*(libHandle: pointer;
+                                name: cstring; function_name: cstring;
+                                attr: GodotMethodAttributes;
+                                meth: GodotInstanceMethod) {.
+    importc: "godot_nativescript_register_method",
+    header: "godot_nativescript.h".}
+type
+  GodotPropertySetFunc* {.importc: "godot_property_set_func",
+                          header: "godot_nativescript.h", bycopy.} = object
+    setFunc* {.importc: "set_func".}: proc (obj: ptr GodotObject;
+                                            methodData: pointer;
+                                            userData: pointer;
+                                            value: Variant) {.noconv.}
+    methodData* {.importc: "method_data".}: pointer
+    freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.}
+
+  GodotPropertyGetFunc* {.importc: "godot_property_get_func",
+                          header: "godot_nativescript.h", bycopy.} = object
+    getFunc* {.importc: "get_func".}:
+      proc (obj: ptr GodotObject; methodData: pointer;
+            userData: pointer): Variant {.noconv.}
+    methodData* {.importc: "method_data".}: pointer
+    freeFunc* {.importc: "free_func".}: proc (a2: pointer) {.noconv.}
+
+proc godotScriptRegisterProperty*(libHandle: pointer;
+                                  name: cstring; path: cstring;
+                                  attr: var GodotPropertyAttributes;
+                                  setFunc: GodotPropertySetFunc;
+                                  getFunc: GodotPropertyGetFunc) {.
+    importc: "godot_nativescript_register_property",
+    header: "godot_nativescript.h".}
+
+type
+  GodotSignalArgument* {.importc: "godot_signal_argument",
+                         header: "godot_nativescript.h", bycopy.} = object
+    name* {.importc: "name".}: GodotString
+    typ* {.importc: "type".}: cint
+    hint* {.importc: "hint".}: GodotPropertyHint
+    hintString* {.importc: "hint_string".}: GodotString
+    usage* {.importc: "usage".}: GodotPropertyUsageFlags
+    defaultValue* {.importc: "default_value".}: Variant
+
+  GodotSignal* {.importc: "godot_signal",
+                 header: "godot_nativescript.h".} = object
+    name* {.importc: "name".}: GodotString
+    numArgs* {.importc: "num_args".}: cint
+    args* {.importc: "args".}: ptr GodotSignalArgument
+    numDefaultArgs* {.importc: "num_default_args".}: cint
+    defaultArgs* {.importc: "default_args".}: ptr Variant
+
+proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring;
+                                signal: GodotSignal) {.
+    importc: "godot_nativescript_register_signal",
+    header: "godot_nativescript.h".}
+
+proc getUserdata*(instance: ptr GodotObject): pointer {.
+    importc: "godot_nativescript_get_userdata", header: "godot_nativescript.h".}
+
+proc godotNew*(p_classname: cstring): ptr GodotObject {.
+  importc: "godot_nativescript_new", header: "godot_nativescript.h".}
+
+proc godotStackBottom*(): pointer {.
+  importc: "godot_get_stack_bottom", header: "godot/gdnative.h".}
+
+proc deinit*(o: ptr GodotObject) {.
+    importc: "godot_object_destroy", header: "godot/gdnative.h".}
+
+# print using Godot's error handler list
+
+proc godotPrintError(description: cstring; function: cstring; file: cstring;
+                     line: cint) {.
+  importc: "godot_print_error", header: "godot/gdnative.h".}
+
+proc godotPrintWarning(description: cstring; function: cstring;
+                       file: cstring; line: cint) {.
+  importc: "godot_print_warning", header: "godot/gdnative.h".}
+
+proc godotPrint(message: GodotString) {.
+  importc: "godot_print", header: "godot/gdnative.h".}
+
+proc print*(message: string) {.inline.} =
+  let s = message.toGodotString()
+  godotPrint(s)
+
+proc print*(message: cstring) {.inline.} =
+  let s = message.toGodotString()
+  godotPrint(s)
+
+template printWarning*(warn: typed) =
+  let (filename, line) = instantiationInfo()
+  godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint)
+
+template printError*(err: typed) =
+  let (filename, line) = instantiationInfo()
+  godotPrintError(cstring($err), nil, cstring(filename), line.cint)

godot/core/godotcoretypes.nim

@@ -1,102 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-type
-  Color* {.byref.} = object
-    r*: float32
-    g*: float32
-    b*: float32
-    a*: float32
-
-  Vector3* {.byref.} = object
-    x*: float32
-    y*: float32
-    z*: float32
-
-  Vector2* {.byref.} = object
-    x*: float32
-    y*: float32
-
-  Plane* {.byref.} = object
-    normal*: Vector3
-    d*: float32
-
-  Basis* {.byref.} = object
-    elements*: array[3, Vector3]
-
-  Quat* {.byref.} = object
-    x*: float32
-    y*: float32
-    z*: float32
-    w*: float32
-
-  AABB* {.byref.} = object
-    position*: Vector3
-    size*: Vector3
-
-  Rect2* {.byref.} = object
-    position*: Vector2
-    size*: Vector2
-
-  Transform2D* {.byref.} = object
-    elements*: array[3, Vector2]
-
-  Transform* {.byref.} = object
-    basis*: Basis
-    origin*: Vector3
-
-  RID* {.byref.} = object
-    data: array[sizeof(int), byte]
-
-  Error* {.size: sizeof(cint), pure.} = enum
-    OK,
-    Failed,    ## Generic fail error
-    Unavailable,    ## What is requested is unsupported/unavailable
-    Unconfigured,   ## The object being used hasnt been properly set up yet
-    Unauthorized,   ## Missing credentials for requested resource
-    ParameterRangeError, ## Parameter given out of range (5)
-    OutOfMemory,  ## Out of memory
-    FileNotFound,
-    FileBadDrive,
-    FileBadPath,
-    FileNoPermission, ##  (10)
-    FileAlreadyInUse,
-    FileCantOpen,
-    FileCantWrite,
-    FileCantRead,
-    FileUnrecognized, ##  (15)
-    FileCorrupt,
-    FileMissingDependencies,
-    FileEOF,
-    CantOpen, ## Can't open a resource/socket/file
-    CantCreate,    ##  (20)
-    QueryFailed,
-    AlreadyInUse,
-    Locked, ## resource is locked
-    Timeout,
-    CantConnect, ##  (25)
-    CantResolve,
-    ConnectionError,
-    CantAquireResource,
-    CantFork,
-    InvalidData, ## Data passed is invalid	(30)
-    InvalidParameter, ## Parameter passed is invalid
-    AlreadyExists, ## When adding, item already exists
-    DoesNotExist, ## When retrieving/erasing, it item does not exist
-    DatabaseCantRead, ## Database is full
-    DatabaseCantWrite, ## Database is full	(35)
-    CompilationFailed,
-    MethodNotFound,
-    LinkFailed,
-    ScriptFailed,
-    CyclicLink, ##  (40)
-    InvalidDeclaration,
-    DuplicateSymbol,
-    PauseError,
-    Busy,
-    Skip, ##  (45)
-    Help,           ## user requested help!!
-    Bug,
-      ## a bug in the software certainly happened, due to a double
-      ## check failing or unexpected behavior.
-    PrinterOnFire, ## the parallel port printer is engulfed in flames
-    WTF ## shit happens, has never been used, though

godot/core/nim.cfg

@@ -1 +0,0 @@
---path:"$projectdir/../"

godot/core/nodepath.nim

@@ -0,0 +1,55 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase, strings
+
+type
+  NodePath* {.importc: "godot_node_path",
+              header: "godot/node_path.h", byref.} = object
+
+proc initNodePath(dest: var NodePath; s: GodotString) {.
+    importc: "godot_node_path_new", header: "godot/node_path.h".}
+proc initNodePath(dest: var NodePath;
+                  src: NodePath) {.
+    importc: "godot_node_path_new_copy", header: "godot/node_path.h".}
+proc deinit(self: var NodePath) {.
+    importc: "godot_node_path_destroy", header: "godot/node_path.h".}
+
+proc initNodePath*(s: string): NodePath {.inline.} =
+  initNodePath(result, s.toGodotString())
+
+proc `=destroy`(self: NodePath) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc `=`(self: var NodePath, other: NodePath) {.inline.} =
+  initNodePath(self, other)
+
+proc toGodotString*(self: NodePath): GodotString {.
+    importc: "godot_node_path_as_string", header: "godot/node_path.h".}
+proc `$`*(self: NodePath): string {.inline.} =
+  let s = self.toGodotString()
+  result = $s
+
+proc isAbsolute*(self: NodePath): bool {.
+    importc: "godot_node_path_is_absolute", header: "godot/node_path.h".}
+proc nameCount*(self: NodePath): cint {.
+    importc: "godot_node_path_get_name_count",
+    header: "godot/node_path.h".}
+proc getName*(self: NodePath; idx: cint): GodotString {.
+    importc: "godot_node_path_get_name", header: "godot/node_path.h".}
+proc subnameCount*(self: NodePath): cint {.
+    importc: "godot_node_path_get_subname_count",
+    header: "godot/node_path.h".}
+proc getSubname*(self: NodePath; idx: cint): GodotString {.
+    importc: "godot_node_path_get_subname",
+    header: "godot/node_path.h".}
+proc property*(self: NodePath): GodotString {.
+    importc: "godot_node_path_get_property", header: "godot/node_path.h".}
+proc isEmpty*(self: NodePath): bool {.
+    importc: "godot_node_path_is_empty", header: "godot/node_path.h".}
+
+proc `==`*(a, b: NodePath): bool {.
+    importc: "godot_node_path_operator_equal",
+    header: "godot/node_path.h".}
+
+converter fromString*(s: string): NodePath =
+  initNodePath(result, s.toGodotString())

godot/core/nodepaths.nim

@@ -1,73 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import hashes
-
-import internal/godotinternaltypes, internal/godotnodepaths,
-       internal/godotstrings
-
-type
-  NodePath* = ref object
-    path: GodotNodePath
-
-proc nodePathFinalizer(path: NodePath) =
-  path.path.deinit()
-
-proc newNodePath*(path: GodotNodePath): NodePath =
-  ## Moves the GodotNodePath into Nim wrapper. The ``path`` will be destroyed
-  ## automatically when the result is no longer referenced.
-  new(result, nodePathFinalizer)
-  result.path = path
-
-proc newNodePath*(s: string): NodePath =
-  new(result, nodePathFinalizer)
-  var str = s.toGodotString()
-  initGodotNodePath(result.path, str)
-  str.deinit()
-
-proc godotNodePath*(path: NodePath): ptr GodotNodePath {.inline.} =
-  ## WARNING: do not keep the returned value for longer than the lifetime of
-  ## ``path``
-  result = addr path.path
-
-proc `$`*(self: NodePath): string {.inline.} =
-  var s = self.path.toGodotString()
-  result = $s
-  s.deinit()
-
-proc hash*(self: NodePath): Hash {.inline.} =
-  ($self).hash()
-
-proc isAbsolute*(self: NodePath): bool {.inline.} =
-  self.path.isAbsolute()
-
-proc nameCount*(self: NodePath): int {.inline.} =
-  int(self.path.nameCount())
-
-proc getName*(self: NodePath; idx: int): string {.inline.} =
-  var s = self.path.getName(idx.cint)
-  result = $s
-  s.deinit()
-
-proc subnameCount*(self: NodePath): int {.inline.} =
-  int(self.path.subnameCount())
-
-proc getSubname*(self: NodePath; idx: int): string {.inline.} =
-  var s = self.path.getSubname(idx.cint)
-  result = $s
-  s.deinit()
-
-proc getConcatenatedSubnames*(self: NodePath): string {.inline.} =
-  var s = self.path.getConcatenatedSubnames()
-  result = $s
-  s.deinit()
-
-proc isEmpty*(self: NodePath): bool {.inline.} =
-  self.path.isEmpty()
-
-proc `==`*(a, b: NodePath): bool =
-  if a.isNil and b.isNil: return true
-  if a.isNil != b.isNil: return false
-  result = a.path == b.path
-
-converter fromString*(s: string): NodePath =
-  newNodePath(s)

godot/core/plane.nim

@@ -0,0 +1,84 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase, vector3, strings
+
+type
+  Plane* {.importc: "godot_plane", header: "godot/plane.h", byref.} = object
+
+proc initPlane(dest: var Plane; a, b, c, d: float32) {.
+    importc: "godot_plane_new_with_reals", header: "godot/plane.h".}
+proc initPlane(dest: var Plane; v1, v2, v3: Vector3) {.
+    importc: "godot_plane_new_with_vectors",
+    header: "godot/plane.h".}
+proc initPlane(dest: var Plane; normal: Vector3; d: float32) {.
+    importc: "godot_plane_new_with_normal",
+    header: "godot/plane.h".}
+
+proc initPlane*(a, b, c, d: float32): Plane =
+  initPlane(result, a, b, c, d)
+
+proc initPlane*(v1, v2, v3: Vector3): Plane =
+  initPlane(result, v1, v2, v3)
+
+proc initPlane*(normal: Vector3; d: float32): Plane =
+  initPlane(result, normal, d)
+
+proc toGodotString*(self: Plane): GodotString {.
+    noSideEffect,
+    importc: "godot_plane_as_string", header: "godot/plane.h".}
+proc `$`*(self: Plane): string {.inline.} =
+  $self.toGodotString()
+
+proc normalized*(self: Plane): Plane {.
+    noSideEffect,
+    importc: "godot_plane_normalized", header: "godot/plane.h".}
+proc center*(self: Plane): Vector3 {.
+    noSideEffect,
+    importc: "godot_plane_center", header: "godot/plane.h".}
+proc getAnyPoint*(self: Plane): Vector3 {.
+    noSideEffect,
+    importc: "godot_plane_get_any_point", header: "godot/plane.h".}
+proc isPointOver*(self: Plane; point: Vector3): bool {.
+    noSideEffect,
+    importc: "godot_plane_is_point_over",
+    header: "godot/plane.h".}
+proc distanceTo*(self: Plane; point: Vector3): float32 {.
+    noSideEffect,
+    importc: "godot_plane_distance_to", header: "godot/plane.h".}
+proc contains*(self: Plane; point: Vector3;
+               epsilon: float32): bool {.
+    noSideEffect,
+    importc: "godot_plane_has_point", header: "godot/plane.h".}
+proc project*(self: Plane; point: Vector3): Vector3 {.
+    noSideEffect,
+    importc: "godot_plane_project", header: "godot/plane.h".}
+proc intersect3*(self: Plane; dest: var Vector3;
+                 b, c: Plane): bool {.
+    noSideEffect,
+    importc: "godot_plane_intersect_3",
+    header: "godot/plane.h".}
+proc intersectsRay*(self: Plane; dest: var Vector3;
+                    v, dir: Vector3): bool {.
+    noSideEffect,
+    importc: "godot_plane_intersects_ray",
+    header: "godot/plane.h".}
+proc intersectsSegment*(self: Plane; dest: var Vector3;
+                        segmentBegin, segmentEnd: Vector3): bool {.
+    noSideEffect, importc: "godot_plane_intersects_segment",
+    header: "godot/plane.h".}
+proc `-`*(self: Plane): Plane {.
+    noSideEffect,
+    importc: "godot_plane_operator_neg", header: "godot/plane.h".}
+proc `==`*(a, b: Plane): bool {.
+    noSideEffect,
+    importc: "godot_plane_operator_equal", header: "godot/plane.h".}
+proc normal*(self: Plane): Vector3 {.
+    noSideEffect,
+    importc: "godot_plane_get_normal", header: "godot/plane.h".}
+proc `normal=`*(self: var Plane; normal: Vector3) {.
+    importc: "godot_plane_set_normal", header: "godot/plane.h".}
+proc d*(self: Plane): float32 {.
+    noSideEffect,
+    importc: "godot_plane_get_d", header: "godot/plane.h".}
+proc `d=`*(self: var Plane; d: float32) {.
+    importc: "godot_plane_set_d", header: "godot/plane.h".}

godot/core/planes.nim

@@ -1,66 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import hashes
-
-import vector3
-
-import internal/godotinternaltypes, internal/godotstrings
-import godotcoretypes, gdnativeapi
-
-proc initPlane*(a, b, c, d: float32): Plane {.inline.} =
-  getGDNativeAPI().planeNewWithReals(result, a, b, c, d)
-
-proc initPlane*(v1, v2, v3: Vector3): Plane {.inline.} =
-  getGDNativeAPI().planeNewWithVectors(result, v1, v2, v3)
-
-proc initPlane*(normal: Vector3; d: float32): Plane {.inline.} =
-  result = Plane(
-    normal: normal,
-    d: d
-  )
-
-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).toPlane()
-
-proc center*(self: Plane): Vector3 {.inline.} =
-  getGDNativeAPI().planeCenter(self).toVector3()
-
-proc getAnyPoint*(self: Plane): Vector3 {.inline.} =
-  getGDNativeAPI().planeGetAnyPoint(self).toVector3()
-
-proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} =
-  getGDNativeAPI().planeIsPointOver(self, point)
-
-proc distanceTo*(self: Plane; point: Vector3): float32 {.inline.} =
-  getGDNativeAPI().planeDistanceTo(self, point)
-
-proc contains*(self: Plane; point: Vector3;
-               epsilon: float32): bool {.inline.} =
-  getGDNativeAPI().planeHasPoint(self, point, epsilon)
-
-proc project*(self: Plane; point: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().planeProject(self, point).toVector3()
-
-proc intersect3*(self: Plane; dest: var Vector3;
-                 b, c: Plane): bool {.inline.} =
-  getGDNativeAPI().planeIntersect3(self, dest, b, c)
-
-proc intersectsRay*(self: Plane; dest: var Vector3;
-                    v, dir: Vector3): bool {.inline.} =
-  getGDNativeAPI().planeIntersectsRay(self, dest, v, dir)
-
-proc intersectsSegment*(self: Plane; dest: var Vector3;
-                        segmentBegin, segmentEnd: Vector3): bool {.inline.} =
-  getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd)
-
-proc `-`*(self: Plane): Plane {.inline.} =
-  getGDNativeAPI().planeOperatorNeg(self).toPlane()
-
-proc `==`*(a, b: Plane): bool {.inline.} =
-  getGDNativeAPI().planeOperatorEqual(a, b)

godot/core/poolarray.nim

@@ -0,0 +1,476 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase, color, vector2, vector3, strings
+
+type
+  PoolByteArray* {.importc: "godot_pool_byte_array",
+                   header: "godot/pool_arrays.h", byref.} = object
+  PoolIntArray* {.importc: "godot_pool_int_array",
+                  header: "godot/pool_arrays.h", byref.} = object
+  PoolRealArray* {.importc: "godot_pool_real_array",
+                   header: "godot/pool_arrays.h", byref.} = object
+  PoolStringArray* {.importc: "godot_pool_string_array",
+                     header: "godot/pool_arrays.h", byref.} = object
+  PoolVector2Array* {.importc: "godot_pool_vector2_array",
+                      header: "godot/pool_arrays.h", byref.} = object
+  PoolVector3Array* {.importc: "godot_pool_vector3_array",
+                      header: "godot/pool_arrays.h", byref.} = object
+  PoolColorArray* {.importc: "godot_pool_color_array",
+                    header: "godot/pool_arrays.h", byref.} = object
+
+# byte
+
+proc initPoolByteArray(dest: var PoolByteArray) {.
+    importc: "godot_pool_byte_array_new", header: "godot/pool_arrays.h".}
+proc initPoolByteArray(dest: var PoolByteArray;
+                       src: PoolByteArray) {.
+    importc: "godot_pool_byte_array_new_copy",
+    header: "godot/pool_arrays.h".}
+proc initPoolByteArray(dest: var PoolByteArray; arr: Array) {.
+    importc: "godot_pool_byte_array_new_with_array",
+    header: "godot/pool_arrays.h".}
+
+proc deinit(self: var PoolByteArray) {.
+    importc: "godot_pool_byte_array_destroy", header: "godot/pool_arrays.h".}
+
+proc initPoolByteArray*(): PoolByteArray {.inline.} =
+  initPoolByteArray(result)
+
+proc initPoolByteArray*(arr: Array): PoolByteArray {.inline.} =
+  initPoolByteArray(result, arr)
+
+proc `=`(self: var PoolByteArray, other: PoolByteArray) {.inline.} =
+  initPoolByteArray(self, other)
+
+proc `=destroy`(self: PoolByteArray) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolByteArray;
+          data: uint8) {.
+    importc: "godot_pool_byte_array_append", header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolByteArray, data: uint8) {.
+    importc: "godot_pool_byte_array_push_back", header: "godot/pool_arrays.h".}
+proc add*(self: var PoolByteArray;
+          arr: PoolByteArray) {.
+    importc: "godot_pool_byte_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolByteArray; idx: cint;
+             data: uint8): Error {.
+    importc: "godot_pool_byte_array_insert", header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolByteArray; idx: cint) {.
+    importc: "godot_pool_byte_array_remove", header: "godot/pool_arrays.h".}
+
+proc reverse*(self: var PoolByteArray) {.
+    importc: "godot_pool_byte_array_invert", header: "godot/pool_arrays.h".}
+proc setLen*(self: var PoolByteArray; size: cint) {.
+    importc: "godot_pool_byte_array_resize", header: "godot/pool_arrays.h".}
+
+proc `[]=`*(self: var PoolByteArray; idx: cint; data: uint8) {.
+    importc: "godot_pool_byte_array_set", header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolByteArray; idx: cint): uint8 {.
+    noSideEffect,
+    importc: "godot_pool_byte_array_get",
+    header: "godot/pool_arrays.h".}
+proc len*(self: PoolByteArray): cint {.
+    noSideEffect,
+    importc: "godot_pool_byte_array_size", header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolByteArray): byte =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolByteArray): tuple[key: cint, val: byte] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
+
+proc initPoolIntArray(dest: var PoolIntArray) {.
+    importc: "godot_pool_int_array_new", header: "godot/pool_arrays.h".}
+proc initPoolIntArray(dest: var PoolIntArray;
+                      src: PoolIntArray) {.
+    importc: "godot_pool_int_array_new_copy", header: "godot/pool_arrays.h".}
+proc initPoolIntArray(dest: var PoolIntArray;
+                      arr: Array) {.
+   importc: "godot_pool_int_array_new_with_array",
+   header: "godot/pool_arrays.h".}
+proc deinit(self: var PoolIntArray) {.
+   importc: "godot_pool_int_array_destroy", header: "godot/pool_arrays.h".}
+
+proc initPoolIntArray*(): PoolIntArray {.inline.} =
+  initPoolIntArray(result)
+
+proc initPoolIntArray*(arr: Array): PoolIntArray {.inline.} =
+  initPoolIntArray(result, arr)
+
+proc `=`(self: var PoolIntArray, other: PoolIntArray) {.inline.} =
+  initPoolIntArray(self, other)
+
+proc `=destroy`(self: PoolIntArray) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolIntArray; data: cint) {.
+    importc: "godot_pool_int_array_append", header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolIntArray; data: cint) {.
+    importc: "godot_pool_int_array_push_back", header: "godot/pool_arrays.h".}
+proc add*(self: var PoolIntArray; arr: PoolIntArray) {.
+    importc: "godot_pool_int_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolIntArray; idx: cint;
+             data: cint): Error {.
+    importc: "godot_pool_int_array_insert", header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolIntArray; idx: cint) {.
+    importc: "godot_pool_int_array_remove", header: "godot/pool_arrays.h".}
+proc reverse*(self: var PoolIntArray) {.
+    importc: "godot_pool_int_array_invert", header: "godot/pool_arrays.h".}
+
+proc setLen*(self: var PoolIntArray; size: cint) {.
+    importc: "godot_pool_int_array_resize", header: "godot/pool_arrays.h".}
+proc `[]=`*(self: var PoolIntArray; idx: cint; data: cint) {.
+    importc: "godot_pool_int_array_set", header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolIntArray; idx: cint): cint {.
+    noSideEffect,
+    importc: "godot_pool_int_array_get",
+    header: "godot/pool_arrays.h".}
+proc len*(self: PoolIntArray): cint {.
+    noSideEffect,
+    importc: "godot_pool_int_array_size",
+    header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolIntArray): cint =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolIntArray): tuple[key: cint, val: cint] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
+
+# Real
+
+proc initPoolRealArray(dest: var PoolRealArray) {.
+    importc: "godot_pool_real_array_new", header: "godot/pool_arrays.h".}
+proc initPoolRealArray(dest: var PoolRealArray;
+                       src: PoolRealArray) {.
+    importc: "godot_pool_real_array_new_copy",
+    header: "godot/pool_arrays.h".}
+proc initPoolRealArray(dest: var PoolRealArray; arr: Array) {.
+    importc: "godot_pool_real_array_new_with_array",
+    header: "godot/pool_arrays.h".}
+
+proc deinit(self: var PoolRealArray) {.
+    importc: "godot_pool_real_array_destroy", header: "godot/pool_arrays.h".}
+
+proc initPoolRealArray*(): PoolRealArray {.inline.} =
+  initPoolRealArray(result)
+
+proc initPoolRealArray*(arr: Array): PoolRealArray {.inline.} =
+  initPoolRealArray(result, arr)
+
+proc `=`(self: var PoolRealArray, other: PoolRealArray) {.inline.} =
+  initPoolRealArray(self, other)
+
+proc `=destroy`(self: PoolRealArray) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolRealArray; data: float32) {.
+    importc: "godot_pool_real_array_append",
+    header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolRealArray; data: float32) {.
+    importc: "godot_pool_real_array_push_back", header: "godot/pool_arrays.h".}
+proc add*(self: var PoolRealArray; arr: PoolRealArray) {.
+    importc: "godot_pool_real_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolRealArray;
+             idx: cint; data: float32): Error {.
+    importc: "godot_pool_real_array_insert", header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolRealArray; idx: cint) {.
+    importc: "godot_pool_real_array_remove", header: "godot/pool_arrays.h".}
+proc reverse*(self: var PoolRealArray) {.
+    importc: "godot_pool_real_array_invert", header: "godot/pool_arrays.h".}
+proc setLen*(self: var PoolRealArray; size: cint) {.
+    importc: "godot_pool_real_array_resize", header: "godot/pool_arrays.h".}
+proc `[]=`*(self: var PoolRealArray; idx: cint; data: float32) {.
+    importc: "godot_pool_real_array_set", header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolRealArray; idx: cint): float32 {.
+    noSideEffect,
+    importc: "godot_pool_real_array_get",
+    header: "godot/pool_arrays.h".}
+proc len*(self: PoolRealArray): cint {.
+    noSideEffect,
+    importc: "godot_pool_real_array_size", header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolRealArray): float32 =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolRealArray): tuple[key: cint, val: float32] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
+
+# String
+
+proc initPoolStringArray(dest: var PoolStringArray) {.
+    importc: "godot_pool_string_array_new", header: "godot/pool_arrays.h".}
+proc initPoolStringArray(dest: var PoolStringArray;
+                         src: PoolStringArray) {.
+    importc: "godot_pool_string_array_new_copy",
+    header: "godot/pool_arrays.h".}
+proc initPoolStringArray(dest: var PoolStringArray; arr: Array) {.
+    importc: "godot_pool_string_array_new_with_array",
+    header: "godot/pool_arrays.h".}
+
+proc deinit(self: var PoolStringArray) {.
+    importc: "godot_pool_string_array_destroy",
+    header: "godot/pool_arrays.h".}
+
+proc initPoolStringArray*(): PoolStringArray {.inline.} =
+  initPoolStringArray(result)
+
+proc initPoolStringArray*(arr: Array): PoolStringArray {.inline.} =
+  initPoolStringArray(result, arr)
+
+proc `=`(self: var PoolStringArray, other: PoolStringArray) {.inline.} =
+  initPoolStringArray(self, other)
+
+proc `=destroy`(self: PoolStringArray) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolStringArray; data: GodotString) {.
+    importc: "godot_pool_string_array_append",
+    header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolStringArray; data: GodotString) {.
+    importc: "godot_pool_string_array_push_back",
+    header: "godot/pool_arrays.h".}
+proc add*(self: var PoolStringArray; arr: PoolStringArray) {.
+    importc: "godot_pool_string_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolStringArray;
+             idx: cint; data: GodotString): Error {.
+    importc: "godot_pool_string_array_insert",
+    header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolStringArray; idx: cint) {.
+    importc: "godot_pool_string_array_remove", header: "godot/pool_arrays.h".}
+proc reverse*(self: var PoolStringArray) {.
+    importc: "godot_pool_string_array_invert", header: "godot/pool_arrays.h".}
+proc setLen*(self: var PoolStringArray; size: cint) {.
+    importc: "godot_pool_string_array_resize", header: "godot/pool_arrays.h".}
+proc `[]=`*(self: var PoolStringArray; idx: cint;
+            data: GodotString) {.
+    importc: "godot_pool_string_array_set",
+    header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolStringArray; idx: cint): GodotString {.
+    noSideEffect,
+    importc: "godot_pool_string_array_get",
+    header: "godot/pool_arrays.h".}
+proc len*(self: PoolStringArray): cint {.
+    noSideEffect,
+    importc: "godot_pool_string_array_size",
+    header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolStringArray): GodotString =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolStringArray): tuple[key: cint, val: GodotString] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
+
+# Vector2
+
+proc initPoolVector2Array(dest: var PoolVector2Array) {.
+    importc: "godot_pool_vector2_array_new", header: "godot/pool_arrays.h".}
+proc initPoolVector2Array(dest: var PoolVector2Array;
+                          src: PoolVector2Array) {.
+    importc: "godot_pool_vector2_array_new_copy",
+    header: "godot/pool_arrays.h".}
+proc initPoolVector2Array(dest: var PoolVector2Array; arr: Array) {.
+    importc: "godot_pool_vector2_array_new_with_array",
+    header: "godot/pool_arrays.h".}
+
+proc deinit(self: var PoolVector2Array) {.
+    importc: "godot_pool_vector2_array_destroy", header: "godot/pool_arrays.h".}
+
+proc initPoolVector2Array*(): PoolVector2Array {.inline.} =
+  initPoolVector2Array(result)
+
+proc initPoolVector2Array*(arr: Array): PoolVector2Array {.inline.} =
+  initPoolVector2Array(result, arr)
+
+proc `=`(self: var PoolVector2Array, other: PoolVector2Array) {.inline.} =
+  initPoolVector2Array(self, other)
+
+proc `=destroy`(self: PoolVector2Array) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolVector2Array; data: Vector2) {.
+    importc: "godot_pool_vector2_array_append",
+    header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolVector2Array; data: Vector2) {.
+    importc: "godot_pool_vector2_array_push_back",
+    header: "godot/pool_arrays.h".}
+proc add*(self: var PoolVector2Array;
+          arr: PoolVector2Array) {.
+    importc: "godot_pool_vector2_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolVector2Array;
+             idx: cint; data: Vector2): Error {.
+    importc: "godot_pool_vector2_array_insert",
+    header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolVector2Array; idx: cint) {.
+    importc: "godot_pool_vector2_array_remove", header: "godot/pool_arrays.h".}
+proc reverse*(self: var PoolVector2Array) {.
+    importc: "godot_pool_vector2_array_invert",
+    header: "godot/pool_arrays.h".}
+proc setLen*(self: var PoolVector2Array; size: cint) {.
+    importc: "godot_pool_vector2_array_resize", header: "godot/pool_arrays.h".}
+proc `[]=`*(self: var PoolVector2Array; idx: cint;
+            data: ptr Vector2) {.
+    importc: "godot_pool_vector2_array_set", header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolVector2Array; idx: cint): Vector2 {.
+    noSideEffect,
+    importc: "godot_pool_vector2_array_get", header: "godot/pool_arrays.h".}
+proc len*(self: PoolVector2Array): cint {.
+    noSideEffect,
+    importc: "godot_pool_vector2_array_size", header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolVector2Array): Vector2 =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolVector2Array): tuple[key: cint, val: Vector2] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
+
+# Vector3
+
+proc initPoolVector3Array*(dest: var PoolVector3Array) {.
+    importc: "godot_pool_vector3_array_new", header: "godot/pool_arrays.h".}
+proc initPoolVector3Array*(dest: var PoolVector3Array;
+                           src: PoolVector3Array) {.
+    importc: "godot_pool_vector3_array_new_copy",
+    header: "godot/pool_arrays.h".}
+proc initPoolVector3Array*(dest: var PoolVector3Array; arr: Array) {.
+    importc: "godot_pool_vector3_array_new_with_array",
+    header: "godot/pool_arrays.h".}
+
+proc deinit(self: var PoolVector3Array) {.
+    importc: "godot_pool_vector3_array_destroy",
+    header: "godot/pool_arrays.h".}
+
+proc initPoolVector3Array*(): PoolVector3Array {.inline.} =
+  initPoolVector3Array(result)
+
+proc initPoolVector3Array*(arr: Array): PoolVector3Array {.inline.} =
+  initPoolVector3Array(result, arr)
+
+proc `=`(self: var PoolVector3Array, other: PoolVector3Array) {.inline.} =
+  initPoolVector3Array(self, other)
+
+proc `=destroy`(self: PoolVector3Array) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolVector3Array;
+          data: Vector3) {.
+    importc: "godot_pool_vector3_array_append",
+    header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolVector3Array;
+               data: Vector3) {.
+    importc: "godot_pool_vector3_array_push_back",
+    header: "godot/pool_arrays.h".}
+proc add*(self: var PoolVector3Array;
+          arr: PoolVector3Array) {.
+    importc: "godot_pool_vector3_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolVector3Array;
+             idx: cint; data: Vector3): Error {.
+    importc: "godot_pool_vector3_array_insert",
+    header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolVector3Array; idx: cint) {.
+    importc: "godot_pool_vector3_array_remove", header: "godot/pool_arrays.h".}
+proc reverse*(self: var PoolVector3Array) {.
+    importc: "godot_pool_vector3_array_invert", header: "godot/pool_arrays.h".}
+proc setLen*(self: var PoolVector3Array; size: cint) {.
+    importc: "godot_pool_vector3_array_resize", header: "godot/pool_arrays.h".}
+proc `[]=`*(self: var PoolVector3Array;
+            idx: cint; data: Vector3) {.
+    importc: "godot_pool_vector3_array_set",
+    header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolVector3Array;
+           idx: cint): Vector3 {.
+    noSideEffect,
+    importc: "godot_pool_vector3_array_get",
+    header: "godot/pool_arrays.h".}
+proc len*(self: PoolVector3Array): cint {.
+    noSideEffect,
+    importc: "godot_pool_vector3_array_size",
+    header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolVector3Array): Vector3 =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolVector3Array): tuple[key: cint, val: Vector3] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])
+
+# Color
+
+proc initPoolColorArray(dest: var PoolColorArray) {.
+    importc: "godot_pool_color_array_new", header: "godot/pool_arrays.h".}
+proc initPoolColorArray(dest: var PoolColorArray;
+                        src: PoolColorArray) {.
+    importc: "godot_pool_color_array_new_copy",
+    header: "godot/pool_arrays.h".}
+proc initPoolColorArray(dest: var PoolColorArray; arr: Array) {.
+    importc: "godot_pool_color_array_new_with_array",
+    header: "godot/pool_arrays.h".}
+
+proc deinit(self: var PoolColorArray) {.
+    importc: "godot_pool_color_array_destroy", header: "godot/pool_arrays.h".}
+
+proc initPoolColorArray*(): PoolColorArray {.inline.} =
+  initPoolColorArray(result)
+
+proc initPoolColorArray*(arr: Array): PoolColorArray {.inline.} =
+  initPoolColorArray(result, arr)
+
+proc `=`(self: var PoolColorArray, other: PoolColorArray) {.inline.} =
+  initPoolColorArray(self, other)
+
+proc `=destroy`(self: PoolColorArray) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc add*(self: var PoolColorArray; data: Color) {.
+    importc: "godot_pool_color_array_append",
+    header: "godot/pool_arrays.h".}
+proc addFirst*(self: var PoolColorArray; data: Color) {.
+    importc: "godot_pool_color_array_push_back",
+    header: "godot/pool_arrays.h".}
+proc add*(self: var PoolColorArray; arr: PoolColorArray) {.
+    importc: "godot_pool_color_array_append_array",
+    header: "godot/pool_arrays.h".}
+proc insert*(self: var PoolColorArray;
+             idx: cint; data: Color): Error {.
+    importc: "godot_pool_color_array_insert",
+    header: "godot/pool_arrays.h".}
+proc delete*(self: var PoolColorArray; idx: cint) {.
+    importc: "godot_pool_color_array_remove", header: "godot/pool_arrays.h".}
+proc reverse*(self: var PoolColorArray) {.
+    importc: "godot_pool_color_array_invert", header: "godot/pool_arrays.h".}
+proc setLen*(self: var PoolColorArray; size: cint) {.
+    importc: "godot_pool_color_array_resize", header: "godot/pool_arrays.h".}
+proc `[]=`*(self: var PoolColorArray; idx: cint;
+            data: Color) {.
+    importc: "godot_pool_color_array_set", header: "godot/pool_arrays.h".}
+proc `[]`*(self: PoolColorArray; idx: cint): Color {.
+    noSideEffect,
+    importc: "godot_pool_color_array_get", header: "godot/pool_arrays.h".}
+proc len*(self: PoolColorArray): cint {.
+    noSideEffect,
+    importc: "godot_pool_color_array_size", header: "godot/pool_arrays.h".}
+
+iterator items*(arr: PoolColorArray): Color =
+  for i in 0..<arr.len:
+    yield arr[i]
+
+iterator pairs*(arr: PoolColorArray): tuple[key: cint, val: Color] =
+  for i in 0..<arr.len:
+    yield (i, arr[i])

godot/core/poolarrays.nim

@@ -1,167 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import hashes
-
-import godotcoretypes
-import internal/godotinternaltypes, internal/godotpoolarrays,
-       internal/godotstrings
-import vector2, vector3, colors
-
-template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName,
-                             initProcName) =
-  type
-    T* = ref object
-      fieldName: GodotT
-
-  proc poolArrayFinalizer(arr: T) =
-    arr.fieldName.deinit()
-
-  proc newProcName*(): T {.inline.} =
-    new(result, poolArrayFinalizer)
-    initProcName(result.fieldName)
-
-  proc fieldName*(self: T): ptr GodotT {.inline.} =
-    ## WARNING: do not keep the returned value for longer than the lifetime of
-    ## the array.
-    addr self.fieldName
-
-  proc newProcName*(arr: GodotT): T {.inline.} =
-    new(result, poolArrayFinalizer)
-    result.fieldName = arr
-
-  proc hash*(arr: T): Hash =
-    for item in arr.fieldName.items():
-      result = result !&
-        (when type(item) is GodotString: ($item).hash() else: item.hash())
-    result = !$result
-
-definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8,
-                    godotPoolByteArray, newPoolByteArray,
-                    initGodotPoolByteArray)
-definePoolArrayBase(PoolIntArray, GodotPoolIntArray, cint,
-                    godotPoolIntArray, newPoolIntArray,
-                    initGodotPoolIntArray)
-definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float32,
-                    godotPoolRealArray, newPoolRealArray,
-                    initGodotPoolRealArray)
-definePoolArrayBase(PoolVector2Array, GodotPoolVector2Array, Vector2,
-                    godotPoolVector2Array, newPoolVector2Array,
-                    initGodotPoolVector2Array)
-definePoolArrayBase(PoolVector3Array, GodotPoolVector3Array, Vector3,
-                    godotPoolVector3Array, newPoolVector3Array,
-                    initGodotPoolVector3Array)
-definePoolArrayBase(PoolColorArray, GodotPoolColorArray, Color,
-                    godotPoolColorArray, newPoolColorArray,
-                    initGodotPoolColorArray)
-definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string,
-                    godotPoolStringArray, newPoolStringArray,
-                    initGodotPoolStringArray)
-
-import arrays
-
-template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
-                         noData = false) =
-
-  proc newProcName*(arr: Array): T {.inline.} =
-    new(result, poolArrayFinalizer)
-    initProcName(result.fieldName, arr.godotArray[])
-
-  proc add*(self: T; arr: T) {.inline.} =
-    self.fieldName.add(arr.fieldName)
-
-  proc delete*(self: T; idx: int) {.inline.} =
-    self.fieldName.delete(idx.cint)
-
-  proc reverse*(self: T) {.inline.} =
-    self.fieldName.reverse()
-
-  proc setLen*(self: T; size: int) {.inline.} =
-    self.fieldName.setLen(size.cint)
-
-  proc len*(self: T): int {.inline.} =
-    self.fieldName.len.int
-
-  proc subarray*(self: T, idxFrom, idxTo: int): T {.inline.} =
-    ## Indexes are inclusive, negative values count from the end of the array.
-    assert(idxFrom >= low(cint) and idxFrom <= high(cint) and
-           idxTo >= low(cint) and idxTo <= high(cint))
-    newProcName(self.fieldName.subarray(idxFrom.cint, idxTo.cint))
-
-  when not noData:
-    proc add*(self: T; data: DataT) {.inline.} =
-      self.fieldName.add(data)
-
-    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, float32,
-                godotPoolRealArray, newPoolRealArray,
-                initGodotPoolRealArray)
-definePoolArray(PoolVector2Array, GodotPoolVector2Array, Vector2,
-                godotPoolVector2Array, newPoolVector2Array,
-                initGodotPoolVector2Array)
-definePoolArray(PoolVector3Array, GodotPoolVector3Array, Vector3,
-                godotPoolVector3Array, newPoolVector3Array,
-                initGodotPoolVector3Array)
-definePoolArray(PoolColorArray, GodotPoolColorArray, Color,
-                godotPoolColorArray, newPoolColorArray,
-                initGodotPoolColorArray)
-definePoolArray(PoolStringArray, GodotPoolStringArray, string,
-                godotPoolStringArray, newPoolStringArray,
-                initGodotPoolStringArray, true)
-
-proc add*(self: PoolStringArray; data: string) =
-  var s = data.toGodotString()
-  self.godotPoolStringArray.add(s)
-  s.deinit()
-
-proc insert*(self: PoolStringArray; idx: int; data: string): Error =
-  var s = data.toGodotString()
-  result = self.godotPoolStringArray.insert(idx.cint, s)
-  s.deinit()
-
-proc `[]=`*(self: PoolStringArray; idx: int; data: string) =
-  var s = data.toGodotString()
-  self.godotPoolStringArray[idx.cint] = s
-  s.deinit()
-
-proc `[]`*(self: PoolStringArray; idx: int): string =
-  var s = self.godotPoolStringArray[idx.cint]
-  result = $s
-  s.deinit()
-
-iterator items*(arr: PoolStringArray): string =
-  for i in 0..<arr.len:
-    yield arr[i]
-
-iterator pairs*(arr: PoolStringArray): tuple[key: int, val: string] =
-  for i in 0..<arr.len:
-    yield (i, arr[i])

godot/core/quat.nim

@@ -0,0 +1,114 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase, vector3, strings
+
+type
+  Quat* {.importc: "godot_quat", header: "godot/quat.h", byref.} = object
+
+proc initQuat(dest: var Quat; x, y, z, w: float32) {.
+    importc: "godot_quat_new", header: "godot/quat.h".}
+proc initQuat(dest: var Quat; axis: Vector3; angle: float32) {.
+    importc: "godot_quat_new_with_axis_angle",
+    header: "godot/quat.h".}
+
+proc initQuat*(x, y, z, w: float32): Quat {.inline.} =
+  initQuat(result, x, y, z, w)
+
+proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} =
+  initQuat(result, axis, angle)
+
+proc x*(self: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_get_x", header: "godot/quat.h".}
+proc `x=`*(self: var Quat; val: float32) {.
+    noSideEffect,
+    importc: "godot_quat_set_x", header: "godot/quat.h".}
+proc y*(self: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_get_y", header: "godot/quat.h".}
+proc `y=`*(self: var Quat; val: float32) {.
+    noSideEffect,
+    importc: "godot_quat_set_y", header: "godot/quat.h".}
+proc z*(self: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_get_z", header: "godot/quat.h".}
+proc `z=`*(self: var Quat; val: float32) {.
+    noSideEffect,
+    importc: "godot_quat_set_z", header: "godot/quat.h".}
+proc w*(self: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_get_w", header: "godot/quat.h".}
+proc `w=`*(self: var Quat; val: float32) {.
+    noSideEffect,
+    importc: "godot_quat_set_w", header: "godot/quat.h".}
+
+proc toGodotString*(self: Quat): GodotString {.
+    noSideEffect,
+    importc: "godot_quat_as_string", header: "godot/quat.h".}
+proc `$`*(self: Quat): string {.inline.} =
+  $self.toGodotString()
+
+proc length*(self: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_length", header: "godot/quat.h".}
+proc lengthSquared*(self: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_length_squared", header: "godot/quat.h".}
+proc normalized*(self: Quat): Quat {.
+    noSideEffect,
+    importc: "godot_quat_normalized", header: "godot/quat.h".}
+proc isNormalized*(self: Quat): bool {.
+    noSideEffect,
+    importc: "godot_quat_is_normalized", header: "godot/quat.h".}
+proc inverse*(self: Quat): Quat {.
+    noSideEffect,
+    importc: "godot_quat_inverse", header: "godot/quat.h".}
+proc dot*(a, b: Quat): float32 {.
+    noSideEffect,
+    importc: "godot_quat_dot", header: "godot/quat.h".}
+proc xform*(self: Quat; v: Vector3): Vector3 {.
+    noSideEffect,
+    importc: "godot_quat_xform", header: "godot/quat.h".}
+proc slerp*(self: Quat; b: Quat; t: float32): Quat {.
+    noSideEffect,
+    importc: "godot_quat_slerp", header: "godot/quat.h".}
+proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.
+    noSideEffect,
+    importc: "godot_quat_slerpni", header: "godot/quat.h".}
+proc cubicSlerp*(self, b, pre_a, post_b: Quat;
+                 t: float32): Quat {.
+    noSideEffect,
+    importc: "godot_quat_cubic_slerp",
+    header: "godot/quat.h".}
+proc `*`*(a: Quat, b: float32): Quat {.
+    noSideEffect,
+    importc: "godot_quat_operator_multiply",
+    header: "godot/quat.h".}
+proc `*=`*(a: var Quat, b: float32) {.inline.} =
+  a = a * b
+
+proc `+`*(a, b: Quat): Quat {.
+    noSideEffect,
+    importc: "godot_quat_operator_add", header: "godot/quat.h".}
+proc `+=`*(a: var Quat, b: Quat) {.inline.} =
+  a = a + b
+
+proc `-`*(a, b: Quat): Quat {.
+    noSideEffect,
+    importc: "godot_quat_operator_substract",
+    header: "godot/quat.h".}
+proc `-=`* (a: var Quat, b: Quat) {.inline.} =
+  a = a - b
+
+proc `/`*(self: Quat; b: float32): Quat {.
+    noSideEffect,
+    importc: "godot_quat_operator_divide", header: "godot/quat.h".}
+proc `/=`*(self: var Quat, b: float32) {.inline.} =
+  self = self / b
+
+proc `==`*(a, b: Quat): bool {.
+    noSideEffect,
+    importc: "godot_quat_operator_equal", header: "godot/quat.h".}
+proc `-`*(self: Quat): Quat {.
+    noSideEffect,
+    importc: "godot_quat_operator_neg", header: "godot/quat.h".}

godot/core/quats.nim

@@ -1,84 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import hashes
-
-import internal/godotinternaltypes, internal/godotstrings
-import godotcoretypes, gdnativeapi
-
-proc initQuat*(x, y, z, w: float32): Quat {.inline.} =
-  result = Quat(
-    x: x,
-    y: y,
-    z: z,
-    w: w
-  )
-
-proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} =
-  getGDNativeAPI().quatNewWithAxisAngle(result, axis, angle)
-
-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)
-
-proc lengthSquared*(self: Quat): float32 {.inline.} =
-  getGDNativeAPI().quatLengthSquared(self)
-
-proc normalized*(self: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatNormalized(self).toQuat()
-
-proc isNormalized*(self: Quat): bool {.inline.} =
-  getGDNativeAPI().quatIsNormalized(self)
-
-proc inverse*(self: Quat): Quat {.inline.} =
-  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).toVector3()
-
-proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
-  getGDNativeAPI().quatSlerp(self, b, t).toQuat()
-
-proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
-  getGDNativeAPI().quatSlerpni(self, b, t).toQuat()
-
-proc cubicSlerp*(self, b, preA, postB: Quat;
-                 t: float32): Quat {.inline.} =
-  getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t).toQuat()
-
-proc `*`*(a: Quat, b: float32): Quat {.inline.} =
-  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).toQuat()
-
-proc `+=`*(a: var Quat, b: Quat) {.inline.} =
-  a = a + b
-
-proc `-`*(a, b: Quat): Quat {.inline.} =
-  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).toQuat()
-
-proc `/=`*(self: var Quat, b: float32) {.inline.} =
-  self = self / b
-
-proc `==`*(a, b: Quat): bool {.inline.} =
-  getGDNativeAPI().quatOperatorEqual(a, b)
-
-proc `-`*(self: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatOperatorNeg(self).toQuat()

godot/core/rect2.nim

@@ -1,153 +1,68 @@
-# Copyright (c) 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
-import hashes
+import godotbase, vector2, strings
 
-import vector2
-import internal/godotinternaltypes, internal/godotstrings
-import godotcoretypes, gdnativeapi
+type
+  Rect2* {.importc: "godot_rect2", header: "godot/rect2.h", byref.} = object
 
-{.push stackTrace: off.}
+proc initRect2(dest: var Rect2; pos, size: Vector2) {.
+    importc: "godot_rect2_new_with_position_and_size",
+    header: "godot/rect2.h".}
+proc initRect2(dest: var Rect2; x, y, sizeX, sizeY: float32) {.
+    importc: "godot_rect2_new", header: "godot/rect2.h".}
 
-proc initRect2*(): Rect2 {.inline, noinit.} =
-  Rect2()
+proc initRect2*(pos, size: Vector2): Rect2 {.inline.} =
+  initRect2(result, pos, size)
 
-proc initRect2*(pos, size: Vector2): Rect2 {.inline, noinit.} =
-  Rect2(position: pos, size: size)
+proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline.} =
+  initRect2(result, x, y, sizeX, sizeY)
 
-proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline, noinit.} =
-  Rect2(position: vec2(x, y), size: vec2(sizeX, sizeY))
+proc toGodotString*(self: Rect2): GodotString {.
+    noSideEffect,
+    importc: "godot_rect2_as_string", header: "godot/rect2.h".}
+proc `$`*(self: Rect2): string {.inline.} =
+  $self.toGodotString()
 
-proc `$`*(self: Rect2): string {.inline, noinit.} =
-  $getGDNativeAPI().rect2AsString(self)
-
-proc hash*(self: Rect2): Hash {.inline, noinit.} =
-  !$(self.position.hash() !& self.size.hash())
-
-proc area*(self: Rect2): float32 {.inline, noinit.} =
-  self.size.x * self.size.y
-
-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 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
-
-  if inside:
-    result = 0'f32
-
-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 hasNoArea*(self: Rect2): bool {.inline, noinit.} =
-  self.size.x <= 0 or self.size.y <= 0
-
-proc clip*(self, b: Rect2): Rect2 {.inline, noinit.} =
-  if not self.intersects(b):
-    return initRect2()
-
-  result = self
-
-  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
+proc area*(self: Rect2): float32 {.
+    noSideEffect,
+    importc: "godot_rect2_get_area", header: "godot/rect2.h".}
+proc intersects*(a, b: Rect2): bool {.
+    noSideEffect,
+    importc: "godot_rect2_intersects", header: "godot/rect2.h".}
+proc encloses*(a, b: Rect2): bool {.
+    noSideEffect,
+    importc: "godot_rect2_encloses", header: "godot/rect2.h".}
+proc hasNoArea*(self: Rect2): bool {.
+    noSideEffect,
+    importc: "godot_rect2_has_no_area", header: "godot/rect2.h".}
+proc clip*(a, b: Rect2): Rect2 {.
+    noSideEffect,
+    importc: "godot_rect2_clip", header: "godot/rect2.h".}
+proc merge*(a, b: Rect2): Rect2 {.
+    noSideEffect,
+    importc: "godot_rect2_merge", header: "godot/rect2.h".}
+proc contains*(self: Rect2; point: Vector2): bool {.
+    noSideEffect,
+    importc: "godot_rect2_has_point", header: "godot/rect2.h".}
+proc grow*(self: Rect2; by: float32): Rect2 {.
+    noSideEffect,
+    importc: "godot_rect2_grow", header: "godot/rect2.h".}
+proc expand*(self: Rect2; to: Vector2): Rect2 {.
+    noSideEffect,
+    importc: "godot_rect2_expand", header: "godot/rect2.h".}
+proc `==`*(a, b: Rect2): bool {.
+    noSideEffect,
+    importc: "godot_rect2_operator_equal",
+    header: "godot/rect2.h".}
+proc position*(self: Rect2): Vector2 {.
+    noSideEffect,
+    importc: "godot_rect2_get_position", header: "godot/rect2.h".}
+proc size*(self: Rect2): Vector2 {.
+    noSideEffect,
+    importc: "godot_rect2_get_size", header: "godot/rect2.h".}
+proc setPosition*(self: var Rect2; pos: Vector2) {.
+    noSideEffect,
+    importc: "godot_rect2_set_position", header: "godot/rect2.h".}
+proc setSize*(self: var Rect2; size: Vector2) {.
+    noSideEffect,
+    importc: "godot_rect2_set_size", header: "godot/rect2.h".}

godot/core/rect3.nim

@@ -0,0 +1,100 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase, plane, vector3, strings
+
+type
+  Rect3* {.importc: "godot_rect3", header: "godot/rect3.h", byref.} = object
+
+proc initRect3(dest: var Rect3; pos, size: Vector3) {.
+    importc: "godot_rect3_new", header: "godot/rect3.h".}
+
+proc initRect3*(pos, size: Vector3): Rect3 {.inline.} =
+  initRect3(result, pos, size)
+
+proc position*(self: Rect3): Vector3 {.
+    noSideEffect,
+    importc: "godot_rect3_get_position", header: "godot/rect3.h".}
+proc setPosition*(self: var Rect3; v: Vector3) {.
+    noSideEffect
+    importc: "godot_rect3_set_position", header: "godot/rect3.h".}
+proc size*(self: Rect3): Vector3 {.
+    noSideEffect,
+    importc: "godot_rect3_get_size", header: "godot/rect3.h".}
+proc setSize*(self: var Rect3; v: Vector3) {.
+    noSideEffect,
+    importc: "godot_rect3_set_size", header: "godot/rect3.h".}
+proc toGodotString*(self: Rect3): GodotString {.
+    noSideEffect,
+    importc: "godot_rect3_as_string", header: "godot/rect3.h".}
+proc `$`*(self: Rect3): string {.inline.} =
+  $self.toGodotString()
+proc area*(self: Rect3): float32 {.
+    noSideEffect,
+    importc: "godot_rect3_get_area", header: "godot/rect3.h".}
+proc hasNoArea*(self: Rect3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_has_no_area", header: "godot/rect3.h".}
+proc hasNoSurface*(self: Rect3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_has_no_surface", header: "godot/rect3.h".}
+proc intersects*(a, b: Rect3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_intersects", header: "godot/rect3.h".}
+proc encloses*(self, other: Rect3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_encloses", header: "godot/rect3.h".}
+proc merge*(self, other: Rect3): Rect3 {.
+    noSideEffect,
+    importc: "godot_rect3_merge", header: "godot/rect3.h".}
+proc intersection*(self, other: Rect3): Rect3 {.
+    noSideEffect,
+    importc: "godot_rect3_intersection", header: "godot/rect3.h".}
+proc intersectsPlane*(self: Rect3; plane: Plane): bool {.
+    noSideEffect,
+    importc: "godot_rect3_intersects_plane",
+    header: "godot/rect3.h".}
+proc intersectsSegment*(self: Rect3; start, to: Vector3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_intersects_segment",
+    header: "godot/rect3.h".}
+proc contains*(self: Rect3; point: Vector3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_has_point", header: "godot/rect3.h".}
+proc getSupport*(self: Rect3; dir: Vector3): Vector3 {.
+    noSideEffect,
+    importc: "godot_rect3_get_support", header: "godot/rect3.h".}
+proc getLongestAxis*(self: Rect3): Vector3 {.
+    noSideEffect,
+    importc: "godot_rect3_get_longest_axis", header: "godot/rect3.h".}
+proc getLongestAxisIndex*(self: Rect3): cint {.
+    noSideEffect,
+    importc: "godot_rect3_get_longest_axis_index",
+    header: "godot/rect3.h".}
+proc getLongestAxisSize*(self: Rect3): float32 {.
+    noSideEffect,
+    importc: "godot_rect3_get_longest_axis_size",
+    header: "godot/rect3.h".}
+proc getShortestAxis*(self: Rect3): Vector3 {.
+    noSideEffect,
+    importc: "godot_rect3_get_shortest_axis", header: "godot/rect3.h".}
+proc getShortestAxisIndex*(self: Rect3): cint {.
+    noSideEffect,
+    importc: "godot_rect3_get_shortest_axis_index",
+    header: "godot/rect3.h".}
+proc getShortestAxisSize*(self: Rect3): float32 {.
+    noSideEffect,
+    importc: "godot_rect3_get_shortest_axis_size",
+    header: "godot/rect3.h".}
+proc expand*(self: Rect3; toPoint: Vector3): Rect3 {.
+    noSideEffect,
+    importc: "godot_rect3_expand", header: "godot/rect3.h".}
+proc grow*(self: Rect3; by: float32): Rect3 {.
+    noSideEffect,
+    importc: "godot_rect3_grow", header: "godot/rect3.h".}
+proc getEndpoint*(self: Rect3; idx: cint): Vector3 {.
+    noSideEffect,
+    importc: "godot_rect3_get_endpoint", header: "godot/rect3.h".}
+proc `==`*(a, b: Rect3): bool {.
+    noSideEffect,
+    importc: "godot_rect3_operator_equal",
+    header: "godot/rect3.h".}

godot/core/rid.nim

@@ -0,0 +1,28 @@
+import godotbase
+
+type
+  RID* {.importc: "godot_rid", header: "godot/rid.h", byref.} = object
+
+proc initRID(dest: var RID) {.
+    importc: "godot_rid_new",
+    header: "godot/rid.h".}
+proc initRID(dest: var RID; obj: ptr GodotObject) {.
+    importc: "godot_rid_new_with_resource", header: "godot/rid.h".}
+
+proc initRID*(): RID {.inline.} =
+  initRID(result)
+
+proc initRID*(obj: ptr GodotObject): RID {.inline.} =
+  initRID(result, obj)
+
+proc idCInt(self: RID): cint {.
+    noSideEffect,
+    importc: "godot_rid_get_id", header: "godot/rid.h".}
+
+proc id*(self: RID): uint32 {.inline.} =
+  cast[uint32](self.idCInt())
+
+proc `==`*(a, b: RID): bool {.
+    importc: "godot_rid_operator_equal", header: "godot/rid.h".}
+proc `<`*(a, b: RID): bool {.
+    importc: "godot_rid_operator_less", header: "godot/rid.h".}

godot/core/rids.nim

@@ -1,26 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import hashes
-
-import godotcoretypes, internal/godotinternaltypes, gdnativeapi
-
-proc initRID*(): RID {.inline.} =
-  getGDNativeAPI().ridNew(result)
-
-proc initRID*(obj: ptr GodotObject): RID {.inline.} =
-  getGDNativeAPI().ridNewWithResource(result, obj)
-
-proc id*(self: RID): uint32 {.inline.} =
-  cast[uint32](getGDNativeAPI().ridGetId(self))
-
-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)
-
-proc `<`*(a, b: RID): bool {.inline.} =
-  getGDNativeAPI().ridOperatorLess(a, b)

godot/core/strings.nim

@@ -0,0 +1,62 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+import godotbase
+
+type
+  GodotString* {.importc: "godot_string", header: "godot/string.h",
+                 byref.} = object
+
+proc initGodotString(dest: var GodotString) {.
+    importc: "godot_string_new", header: "godot/string.h".}
+proc initGodotString(dest: var GodotString; src: GodotString) {.
+    importc: "godot_string_new_copy", header: "godot/string.h".}
+proc initGodotString(dest: var GodotString; contents: cstring;
+                      size: cint) {.
+    importc: "godot_string_new_data", header: "godot/string.h".}
+  ## Initializes ``dest`` from UTF-8 ``contents``
+proc getData(self: GodotString; dest: cstring;
+             size: var cint) {.
+    noSideEffect
+    importc: "godot_string_get_data",
+    header: "godot/string.h".}
+  ## Converts ``self`` into UTF-8 encoding, putting the result into ``dest``.
+
+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 {.
+    importc: "godot_string_c_str", header: "godot/string.h".}
+proc `==`*(self, b: GodotString): bool {.
+    importc: "godot_string_operator_equal",
+    header: "godot/string.h".}
+proc `<`*(self, b: GodotString): bool {.
+    importc: "godot_string_operator_less",
+    header: "godot/string.h".}
+proc `&`*(self, b: GodotString): GodotString {.
+    importc: "godot_string_operator_plus",
+    header: "godot/string.h".}
+
+proc deinit*(self: var GodotString) {.importc: "godot_string_destroy",
+                                      header: "godot/string.h".}
+proc `=destroy`(self: GodotString) {.inline.} =
+  unsafeAddr(self).deinit()
+
+proc `=`(self: var GodotString, other: GodotString) {.inline.} =
+  initGodotString(self, other)
+
+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')
+
+proc toGodotString*(s: string): GodotString {.inline.} =
+  ## Converts the Nim string into ``GodotString``
+  initGodotString(result, unsafeAddr s[0], cint(s.len + 1))
+
+proc toGodotString*(s: cstring): GodotString {.inline.} =
+  ## Converts the cstring into ``GodotString``
+  initGodotString(result, s, cint(s.len + 1))

godot/core/transform.nim

@@ -0,0 +1,82 @@
+# Copyright (c) 2017 Xored Software, Inc.
+
+type
+  Transform* {.importc: "godot_transform", header: "godot/transform.h",
+               byref.} = object
+
+import godotbase, basis, variant, vector3, strings, plane, rect3
+
+proc initTransform(dest: var Transform) {.
+    importc: "godot_transform_new_identity", header: "godot/transform.h".}
+  ## Initializes the ``dest`` as identity transform.
+proc initTransform(dest: var Transform;
+                   xAxis, yAxis, zAxis, origin: Vector3) {.
+    importc: "godot_transform_new_with_axis_origin",
+    header: "godot/transform.h".}
+proc initTransform(dest: var Transform; basis: Basis;
+                   origin: Vector3) {.
+    importc: "godot_transform_new",
+    header: "godot/transform.h".}
+
+proc initTransform*(): Transform {.inline.} =
+  initTransform(result)
+
+proc initTransform*(xAxis, yAxis, zAxis,
+                    origin: Vector3): Transform {.inline.} =
+  initTransform(result, xAxis, yAxis, zAxis, origin)
+
+proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} =
+  initTransform(result, basis, origin)
+
+proc basis*(self: Transform): Basis {.
+    importc: "godot_transform_get_basis", header: "godot/transform.h".}
+proc `basis=`*(self: var Transform; v: Basis) {.
+    importc: "godot_transform_set_basis", header: "godot/transform.h".}
+proc origin*(self: Transform): Vector3 {.
+    importc: "godot_transform_get_origin", header: "godot/transform.h".}
+proc `origin=`*(self: var Transform; v: Vector3) {.
+    importc: "godot_transform_set_origin", header: "godot/transform.h".}
+
+proc toGodotString*(self: Transform): GodotString {.
+    importc: "godot_transform_as_string", header: "godot/transform.h".}
+proc `$`*(self: Transform): string {.inline.} =
+  $self.toGodotString()
+
+proc inverse*(self: Transform): Transform {.
+    importc: "godot_transform_inverse", header: "godot/transform.h".}
+proc affineInverse*(self: Transform): Transform {.
+    importc: "godot_transform_affine_inverse",
+    header: "godot/transform.h".}
+proc orthonormalized*(self: Transform): Transform {.
+    importc: "godot_transform_orthonormalized",
+    header: "godot/transform.h".}
+proc rotated*(self: Transform; axis: Vector3;
+              phi: float32): Transform {.
+    importc: "godot_transform_rotated", header: "godot/transform.h".}
+proc scaled*(self: Transform; scale: Vector3): Transform {.
+    importc: "godot_transform_scaled", header: "godot/transform.h".}
+proc translated*(self: Transform; offset: Vector3): Transform {.
+    importc: "godot_transform_translated", header: "godot/transform.h".}
+proc lookingAt*(self: Transform;
+                target, up: Vector3): Transform {.
+    importc: "godot_transform_looking_at", header: "godot/transform.h".}
+
+proc xformPlane*(self: Transform; v: Plane): Plane {.
+    importc: "godot_transform_xform_plane", header: "godot/transform.h".}
+proc xformInvPlane*(self: Transform; v: Plane): Plane {.
+    importc: "godot_transform_xform_inv_plane", header: "godot/transform.h".}
+proc xformVector3*(self: Transform; v: Vector3): Vector3 {.
+    importc: "godot_transform_xform_vector3", header: "godot/transform.h".}
+proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.
+    importc: "godot_transform_xform_inv_vector3", header: "godot/transform.h".}
+proc xformRect3*(self: Transform; v: Vector3): Rect3 {.
+    importc: "godot_transform_xform_rect3", header: "godot/transform.h".}
+proc xformInvRect3*(self: Transform; v: Vector3): Vector3 {.
+    importc: "godot_transform_xform_inv_rect3", header: "godot/transform.h".}
+
+proc `==`*(self: Transform; b: Transform): bool {.
+    importc: "godot_transform_operator_equal", header: "godot/transform.h".}
+proc `*`*(a, b: Transform): Transform {.
+    importc: "godot_transform_operator_multiply", header: "godot/transform.h".}
+proc `*=`*(a: var Transform, b: Transform) {.inline.} =
+  a = a * b

godot/core/transform2d.nim

@@ -1,79 +1,92 @@
-# Copyright (c) 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
-import hashes, vector2
+type
+  Transform2D* {.importc: "godot_transform2d", header: "godot/transform2d.h",
+                 byref.} = object
 
-import internal/godotinternaltypes, internal/godotstrings
-import godotcoretypes, gdnativeapi
+import godotbase, strings, variant, vector2, rect2
+
+proc initTransform2D(dest: var Transform2D) {.
+    importc: "godot_transform2d_new_identity", header: "godot/transform2d.h".}
+proc initTransform2D(dest: var Transform2D; rot: float32; pos: Vector2) {.
+    importc: "godot_transform2d_new", header: "godot/transform2d.h".}
+proc initTransform2D(dest: var Transform2D; xAxis, yAxis, origin: Vector2) {.
+    importc: "godot_transform2d_new_axis_origin",
+    header: "godot/transform2d.h".}
 
 proc initTransform2D*(): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DNewIdentity(result)
+  initTransform2D(result)
 
 proc initTransform2D*(rot: float32; pos: Vector2): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DNew(result, rot, pos)
+  initTransform2D(result, rot, pos)
 
 proc initTransform2D*(xAxis, yAxis, origin: Vector2): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DNewAxisOrigin(result, xAxis, yAxis, origin)
+  initTransform2D(result, xAxis, yAxis, origin)
 
+proc toGodotString*(self: Transform2D): GodotString {.
+    importc: "godot_transform2d_as_string",
+    header: "godot/transform2d.h".}
 proc `$`*(self: Transform2D): string {.inline.} =
-  $getGDNativeAPI().transform2DAsString(self)
+  $self.toGodotString()
 
-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).toTransform2D()
-
-proc affineInverse*(self: Transform2D): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DAffineInverse(self).toTransform2D()
-
-proc rotation*(self: Transform2D): float32 {.inline.} =
-  getGDNativeAPI().transform2DGetRotation(self)
-
-proc origin*(self: Transform2D): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DGetOrigin(self).toVector2()
-
-proc scale*(self: Transform2D): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DGetScale(self).toVector2()
-
-proc orthonormalized*(self: Transform2D): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DOrthonormalized(self).toTransform2D()
-
-proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DRotated(self, phi).toTransform2D()
-
-proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DScaled(self, scale).toTransform2D()
-
-proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DTranslated(self, offset).toTransform2D()
-
-proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DXformVector2(self, v).toVector2()
-
-proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DXformInvVector2(self, v).toVector2()
-
-proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DBasisXformVector2(self, v).toVector2()
-
-proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DBasisXformInvVector2(self, v).toVector2()
-
-proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
-  getGDNativeAPI().transform2DXformRect2(self, rect).toRect2()
-
-proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
-  getGDNativeAPI().transform2DXformInvRect2(self, rect).toRect2()
+proc inverse*(self: Transform2D): Transform2D {.
+    importc: "godot_transform2d_inverse", header: "godot/transform2d.h".}
+proc affineInverse*(self: Transform2D): Transform2D {.
+    importc: "godot_transform2d_affine_inverse",
+    header: "godot/transform2d.h".}
+proc rotation*(self: Transform2D): float32 {.
+    importc: "godot_transform2d_get_rotation",
+    header: "godot/transform2d.h".}
+proc origin*(self: Transform2D): Vector2 {.
+    importc: "godot_transform2d_get_origin",
+    header: "godot/transform2d.h".}
+proc scale*(self: Transform2D): Vector2 {.
+    importc: "godot_transform2d_get_scale",
+    header: "godot/transform2d.h".}
+proc orthonormalized*(self: Transform2D): Transform2D {.
+    importc: "godot_transform2d_orthonormalized",
+    header: "godot/transform2d.h".}
+proc rotated*(self: Transform2D; phi: float32): Transform2D {.
+    importc: "godot_transform2d_rotated",
+    header: "godot/transform2d.h".}
+proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.
+    importc: "godot_transform2d_scaled",
+    header: "godot/transform2d.h".}
+proc translated*(self: Transform2D;
+                 offset: Vector2): Transform2D {.
+    importc: "godot_transform2d_translated",
+    header: "godot/transform2d.h".}
+proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.
+    importc: "godot_transform2d_xform_vector2",
+    header: "godot/transform2d.h".}
+proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.
+    importc: "godot_transform2d_xform_inv_vector2",
+    header: "godot/transform2d.h".}
+proc basisXformVector2*(self: Transform2D;
+                        v: Vector2): Vector2 {.
+    importc: "godot_transform2d_basis_xform_vector2",
+    header: "godot/transform2d.h".}
+proc basisXformInvVector2*(self: Transform2D;
+                           v: Vector2): Vector2 {.
+    importc: "godot_transform2d_basis_xform_inv_vector2",
+    header: "godot/transform2d.h".}
+proc xformRect2*(self: Transform2D; v: Rect2): Rect2 {.
+    importc: "godot_transform2d_xform_rect2", header: "godot/transform2d.h".}
+proc xformInvRect2*(self: Transform2D; v: Rect2): Rect2 {.
+    importc: "godot_transform2d_xform_inv_rect2",
+    header: "godot/transform2d.h".}
 
 proc interpolateWith*(self, m: Transform2D;
-                      c: float32): Transform2D {.inline.} =
-  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).toTransform2D()
+                      c: float32): Transform2D {.
+    importc: "godot_transform2d_interpolate_with",
+    header: "godot/transform2d.h".}
+proc `==`*(a, b: Transform2D): bool {.
+    importc: "godot_transform2d_operator_equal",
+    header: "godot/transform2d.h".}
+proc `*`*(a, b: Transform2D): Transform2D {.
+    importc: "godot_transform2d_operator_multiply",
+    header: "godot/transform2d.h".}
 
 proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} =
   a = a * b
+

godot/core/transforms.nim

@@ -1,76 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import hashes
-
-import internal/godotinternaltypes, internal/godotstrings
-import godotcoretypes, gdnativeapi
-import basis, vector3
-
-proc initTransform*(): Transform {.inline.} =
-  result.basis = initBasis()
-
-proc initTransform*(xAxis, yAxis, zAxis,
-                    origin: Vector3): Transform {.inline.} =
-  var basis: Basis
-  basis.setAxis(0, xAxis)
-  basis.setAxis(1, yAxis)
-  basis.setAxis(2, zAxis)
-  Transform(basis: basis, origin: origin)
-
-proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} =
-  Transform(basis: basis, origin: origin)
-
-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).toTransform()
-
-proc affineInverse*(self: Transform): Transform {.inline.} =
-  getGDNativeAPI().transformAffineInverse(self).toTransform()
-
-proc orthonormalized*(self: Transform): Transform {.inline.} =
-  getGDNativeAPI().transformOrthonormalized(self).toTransform()
-
-proc rotated*(self: Transform; axis: Vector3;
-              phi: float32): Transform {.inline.} =
-  getGDNativeAPI().transformRotated(self, axis, phi).toTransform()
-
-proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} =
-  getGDNativeAPI().transformScaled(self, scale).toTransform()
-
-proc translated*(self: Transform; offset: Vector3): Transform {.inline.} =
-  getGDNativeAPI().transformTranslated(self, offset).toTransform()
-
-proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} =
-  getGDNativeAPI().transformLookingAt(self, target, up).toTransform()
-
-proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} =
-  getGDNativeAPI().transformXformPlane(self, plane).toPlane()
-
-proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} =
-  getGDNativeAPI().transformXformInvPlane(self, plane).toPlane()
-
-proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().transformXformVector3(self, v).toVector3()
-
-proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().transformXformInvVector3(self, v).toVector3()
-
-proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} =
-  getGDNativeAPI().transformXformAABB(self, rect).toAABB()
-
-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).toTransform()
-
-proc `*=`*(self: var Transform, other: Transform) {.inline.} =
-  self = self * other

godot/core/variant.nim

@@ -0,0 +1,291 @@
+import godotbase
+
+import arrays, basis, nodepath
+import plane, poolarray, quat, rect2, rect3, rid
+import strings, transform, transform2d, vector2
+import vector3, color
+
+type
+  VariantType* {.importc: "godot_variant_type", header: "godot/variant.h",
+                 size: sizeof(cint), pure.} = enum
+    Nil,   ##  atomic types
+    Bool,
+    Int,
+    Real,
+    String,
+    # math types
+    Vector2, ##  5
+    Rect2,
+    Vector3,
+    Transform2D,
+    Plane,
+    Quat, ##  10
+    Rect3,
+    Basis,
+    Transform, ##  misc types
+    Color,
+    NodePath, ##  15
+    RID,
+    Object,
+    Dictionary,
+    Array, ##  20
+    # arrays
+    PoolByteArray,
+    PoolIntArray,
+    PoolRealArray,
+    PoolStringArray,
+    PoolVector2Array, ##  25
+    PoolVector3Array,
+    PoolColorArray
+
+  VariantCallErrorType* {.importc: "godot_variant_call_error_error",
+                          header: "godot/variant.h",
+                          size: sizeof(cint),
+                          pure.} = enum
+    OK,
+    InvalidMethod,
+    InvalidArgument,
+    TooManyArguments,
+    TooFewArguments,
+    InstanceIsNull
+
+  VariantCallError* {.importc: "godot_variant_call_error",
+                      header: "godot/variant.h".} = object
+    error* {.importc: "error".}: VariantCallErrorType
+    argument* {.importc: "argument".}: cint
+    expected* {.importc: "expected".}: VariantType
+
+proc getType*(p: Variant): VariantType {.
+    importc: "godot_variant_get_type", header: "godot/variant.h".}
+
+proc initNilVariant(dest: var Variant) {.
+    importc: "godot_variant_new_nil", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; b: bool) {.
+    importc: "godot_variant_new_bool", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; i: uint64) {.
+    importc: "godot_variant_new_uint", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; i: int64) {.
+    importc: "godot_variant_new_int", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; r: cdouble) {.
+    importc: "godot_variant_new_real", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; s: GodotString) {.
+    importc: "godot_variant_new_string", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; v2: Vector2) {.
+    importc: "godot_variant_new_vector2", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; rect2: Rect2) {.
+    importc: "godot_variant_new_rect2", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; v3: Vector3) {.
+    importc: "godot_variant_new_vector3", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; t2d: Transform2D) {.
+    importc: "godot_variant_new_transform2d",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; plane: Plane) {.
+    importc: "godot_variant_new_plane", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; quat: Quat) {.
+    importc: "godot_variant_new_quat", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; rect3: Rect3) {.
+    importc: "godot_variant_new_rect3", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; basis: Basis) {.
+    importc: "godot_variant_new_basis", header: "godot/variant.h".}
+proc initVariant(dest: var Variant;
+                 trans: Transform) {.
+    importc: "godot_variant_new_transform",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; color: Color) {.
+    importc: "godot_variant_new_color", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; nodePath: NodePath) {.
+    importc: "godot_variant_new_node_path",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; rid: RID) {.
+    importc: "godot_variant_new_rid", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; obj: ptr GodotObject) {.
+    importc: "godot_variant_new_object", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; arr: Array) {.
+    importc: "godot_variant_new_array", header: "godot/variant.h".}
+proc initVariant(dest: var Variant; pba: PoolByteArray) {.
+    importc: "godot_variant_new_pool_byte_array",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; pia: PoolIntArray) {.
+    importc: "godot_variant_new_pool_int_array",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; pra: PoolRealArray) {.
+    importc: "godot_variant_new_pool_real_array",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; psa: PoolStringArray) {.
+    importc: "godot_variant_new_pool_string_array",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; pv2a: PoolVector2Array) {.
+    importc: "godot_variant_new_pool_vector2_array",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; pv3a: PoolVector3Array) {.
+    importc: "godot_variant_new_pool_vector3_array",
+    header: "godot/variant.h".}
+proc initVariant(dest: var Variant; pca: PoolColorArray) {.
+    importc: "godot_variant_new_pool_color_array",
+    header: "godot/variant.h".}
+
+proc variant*(): Variant {.inline.} =
+  initNilVariant(result)
+
+proc variant*(b: bool): Variant {.inline.} =
+  initVariant(result, b)
+
+proc variant*(i: uint64): Variant {.inline.} =
+  initVariant(result, i)
+
+proc variant*(i: int64): Variant {.inline.} =
+  initVariant(result, i)
+
+proc variant*(r: cdouble): Variant {.inline.} =
+  initVariant(result, r)
+
+proc variant*(s: GodotString): Variant {.inline.} =
+  initVariant(result, s)
+
+proc variant*(s: string): Variant {.inline.} =
+  let godotStr = s.toGodotString()
+  initVariant(result, godotStr)
+
+proc variant*(v2: Vector2): Variant {.inline.} =
+  initVariant(result, v2)
+
+proc variant*(rect2: Rect2): Variant {.inline.} =
+  initVariant(result, rect2)
+
+proc variant*(v3: Vector3): Variant {.inline.} =
+  initVariant(result, v3)
+
+proc variant*(t2d: Transform2D): Variant {.inline.} =
+  initVariant(result, t2d)
+
+proc variant*(plane: Plane): Variant {.inline.} =
+  initVariant(result, plane)
+
+proc variant*(quat: Quat): Variant {.inline.} =
+  initVariant(result, quat)
+
+proc variant*(rect3: Rect3): Variant {.inline.} =
+  initVariant(result, rect3)
+
+proc variant*(basis: Basis): Variant {.inline.} =
+  initVariant(result, basis)
+
+proc variant*(trans: Transform): Variant {.inline.} =
+  initVariant(result, trans)
+
+proc variant*(color: Color): Variant {.inline.} =
+  initVariant(result, color)
+
+proc variant*(nodePath: NodePath): Variant {.inline.} =
+  initVariant(result, nodePath)
+
+proc variant*(rid: RID): Variant {.inline.} =
+  initVariant(result, rid)
+
+proc variant*(obj: ptr GodotObject): Variant {.inline.} =
+  initVariant(result, obj)
+
+proc variant*(arr: Array): Variant {.inline.} =
+  initVariant(result, arr)
+
+proc variant*(pba: PoolByteArray): Variant {.inline.} =
+  initVariant(result, pba)
+
+proc variant*(pia: PoolIntArray): Variant {.inline.} =
+  initVariant(result, pia)
+
+proc variant*(pra: PoolRealArray): Variant {.inline.} =
+  initVariant(result, pra)
+
+proc variant*(psa: PoolStringArray): Variant {.inline.} =
+  initVariant(result, psa)
+
+proc variant*(pv2a: PoolVector2Array): Variant {.inline.} =
+  initVariant(result, pv2a)
+
+proc variant*(pv3a: PoolVector3Array): Variant {.inline.} =
+  initVariant(result, pv3a)
+
+proc variant*(pca: PoolColorArray): Variant {.inline.} =
+  initVariant(result, pca)
+
+proc asBool*(self: Variant): bool {.
+    importc: "godot_variant_as_bool", header: "godot/variant.h".}
+proc asUint*(self: Variant): uint64 {.
+    importc: "godot_variant_as_uint", header: "godot/variant.h".}
+proc asInt*(self: Variant): int64 {.
+    importc: "godot_variant_as_int", header: "godot/variant.h".}
+proc asReal*(self: Variant): cdouble {.
+    importc: "godot_variant_as_real", header: "godot/variant.h".}
+proc asGodotString*(self: Variant): GodotString {.
+    importc: "godot_variant_as_string", header: "godot/variant.h".}
+
+proc asString*(self: Variant): string =
+  let s = self.asGodotString()
+  result = $s
+
+proc asVector2*(self: Variant): Vector2 {.
+    importc: "godot_variant_as_vector2", header: "godot/variant.h".}
+proc asRect2*(self: Variant): Rect2 {.
+    importc: "godot_variant_as_rect2", header: "godot/variant.h".}
+proc asVector3*(self: Variant): Vector3 {.
+    importc: "godot_variant_as_vector3", header: "godot/variant.h".}
+proc asTransform2D*(self: Variant): Transform2D {.
+    importc: "godot_variant_as_transform2d", header: "godot/variant.h".}
+proc asPlane*(self: Variant): Plane {.
+    importc: "godot_variant_as_plane", header: "godot/variant.h".}
+proc asQuat*(self: Variant): Quat {.
+    importc: "godot_variant_as_quat", header: "godot/variant.h".}
+proc asRect3*(self: Variant): Rect3 {.
+    importc: "godot_variant_as_rect3", header: "godot/variant.h".}
+proc asBasis*(self: Variant): Basis {.
+    importc: "godot_variant_as_basis", header: "godot/variant.h".}
+proc asTransform*(self: Variant): Transform {.
+    importc: "godot_variant_as_transform", header: "godot/variant.h".}
+proc asColor*(self: Variant): Color {.
+    importc: "godot_variant_as_color", header: "godot/variant.h".}
+proc asNodePath*(self: Variant): NodePath {.
+    importc: "godot_variant_as_node_path", header: "godot/variant.h".}
+proc asRid*(self: Variant): RID {.
+    importc: "godot_variant_as_rid", header: "godot/variant.h".}
+proc asObject*(self: Variant): ptr GodotObject {.
+    importc: "godot_variant_as_object", header: "godot/variant.h".}
+proc asArray*(self: Variant): Array {.
+    importc: "godot_variant_as_array", header: "godot/variant.h".}
+proc asPoolByteArray*(self: Variant): PoolByteArray {.
+    importc: "godot_variant_as_pool_byte_array",
+    header: "godot/variant.h".}
+proc asPoolIntArray*(self: Variant): PoolIntArray {.
+    importc: "godot_variant_as_pool_int_array",
+    header: "godot/variant.h".}
+proc asPoolRealArray*(self: Variant): PoolRealArray {.
+    importc: "godot_variant_as_pool_real_array",
+    header: "godot/variant.h".}
+proc asPoolStringArray*(self: Variant): PoolStringArray {.
+    importc: "godot_variant_as_pool_string_array",
+    header: "godot/variant.h".}
+proc asPoolVector2Array*(self: Variant): PoolVector2Array {.
+    importc: "godot_variant_as_pool_vector2_array",
+    header: "godot/variant.h".}
+proc asPoolVector3Array*(self: Variant): PoolVector3Array {.
+    importc: "godot_variant_as_pool_vector3_array",
+    header: "godot/variant.h".}
+proc asPoolColorArray*(self: Variant): PoolColorArray {.
+    importc: "godot_variant_as_pool_color_array",
+    header: "godot/variant.h".}
+
+proc call*(self: Variant; meth: GodotString;
+           args: var array[MAX_ARG_COUNT, Variant]; argCount: cint;
+           error: var VariantCallError): Variant {.
+    importc: "godot_variant_call", header: "godot/variant.h".}
+
+proc hasMethod*(self: Variant; meth: GodotString): bool {.
+    importc: "godot_variant_has_method", header: "godot/variant.h".}
+proc `==`*(self, other: Variant): bool {.
+    importc: "godot_variant_operator_equal", header: "godot/variant.h".}
+proc `<`*(self, other: Variant): bool {.
+    importc: "godot_variant_operator_less", header: "godot/variant.h".}
+proc hashCompare*(self, other: Variant): bool {.
+    importc: "godot_variant_hash_compare", header: "godot/variant.h".}
+proc booleanize*(self: Variant; isValid: var bool): bool {.
+    importc: "godot_variant_booleanize", header: "godot/variant.h".}

godot/core/variants.nim

@@ -1,308 +0,0 @@
-import tables, hashes
-
-import godotcoretypes
-import internal/godotinternaltypes, internal/godotvariants,
-       internal/godotstrings, internal/godotdictionaries,
-       internal/godotarrays
-
-type
-  Variant* = ref object
-    godotVariant: GodotVariant
-    noDeinit: bool # used to avoid copying when passing the variant to Godot
-
-export VariantType, VariantCallErrorType, VariantCallError
-
-proc markNoDeinit*(v: Variant) {.inline.} =
-  ## Makes it so that internal GodotVariant object will not be destroyed
-  ## when the reference is gone. Use only if you know what you are doing.
-  v.noDeinit = true
-
-proc godotVariant*(v: Variant): ptr GodotVariant {.inline.} =
-  ## WARNING: do not keep the returned value for longer than the lifetime of
-  ## ``v``
-  addr v.godotVariant
-
-proc getType*(v: Variant): VariantType =
-  v.godotVariant.getType()
-
-proc variantFinalizer*(v: Variant) =
-  if not v.noDeinit:
-    v.godotVariant.deinit()
-
-proc `$`*(self: Variant): string {.inline.} =
-  $self.godotVariant
-
-proc newVariant*(): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant)
-
-proc newVariant*(v: Variant): Variant {.inline.} =
-  ## Makes a copy
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, v.godotVariant)
-
-proc newVariant*(v: GodotVariant): Variant {.inline.} =
-  new(result, variantFinalizer)
-  result.godotVariant = v
-
-proc newVariant*(b: bool): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, b)
-
-# resolves Nim call ambiguities well
-template numConstructor(T, ConvT) =
-  proc newVariant*(i: T): Variant {.inline.} =
-    new(result, variantFinalizer)
-    initGodotVariant(result.godotVariant, ConvT(i))
-
-numConstructor(uint8, uint64)
-numConstructor(uint16, uint64)
-numConstructor(uint32, uint64)
-numConstructor(uint64, uint64)
-numConstructor(uint, uint64)
-
-numConstructor(int8, int64)
-numConstructor(int16, int64)
-numConstructor(int32, int64)
-numConstructor(int64, int64)
-numConstructor(int, int64)
-
-proc newVariant*(r: cdouble): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, r)
-
-proc newVariant*(s: string): Variant {.inline.} =
-  new(result, variantFinalizer)
-  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
-    if s.isNil:
-      initGodotVariant(result.godotVariant)
-      return
-  var godotStr = s.toGodotString()
-  initGodotVariant(result.godotVariant, godotStr)
-  godotStr.deinit()
-
-import basis, nodepaths
-import planes, quats, rect2, aabb, rids
-import transforms, transform2d, vector2
-import vector3, colors
-
-proc newVariant*(v2: Vector2): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, v2)
-
-proc newVariant*(rect2: Rect2): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, rect2)
-
-proc newVariant*(v3: Vector3): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, v3)
-
-proc newVariant*(t2d: Transform2D): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, t2d)
-
-proc newVariant*(plane: Plane): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, plane)
-
-proc newVariant*(quat: Quat): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, quat)
-
-proc newVariant*(aabb: AABB): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, aabb)
-
-proc newVariant*(basis: Basis): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, basis)
-
-proc newVariant*(trans: Transform): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, trans)
-
-proc newVariant*(color: Color): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, color)
-
-proc newVariant*(nodePath: NodePath): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, nodePath.godotNodePath[])
-
-proc newVariant*(godotNodePath: GodotNodePath): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, godotNodePath)
-
-proc newVariant*(rid: RID): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, rid)
-
-proc newVariant*(obj: ptr GodotObject): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, obj)
-
-import poolarrays
-
-proc newVariant*(pba: PoolByteArray): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, pba.godotPoolByteArray[])
-
-proc newVariant*(pia: PoolIntArray): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, pia.godotPoolIntArray[])
-
-proc newVariant*(pra: PoolRealArray): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, pra.godotPoolRealArray[])
-
-proc newVariant*(psa: PoolStringArray): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, psa.godotPoolStringArray[])
-
-proc newVariant*(pv2a: PoolVector2Array): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, pv2a.godotPoolVector2Array[])
-
-proc newVariant*(pv3a: PoolVector3Array): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, pv3a.godotPoolVector3Array[])
-
-proc newVariant*(pca: PoolColorArray): Variant {.inline.} =
-  new(result, variantFinalizer)
-  initGodotVariant(result.godotVariant, pca.godotPoolColorArray[])
-
-proc asBool*(self: Variant): bool {.inline.} =
-  self.godotVariant.asBool()
-
-proc asUInt*(self: Variant): uint64 {.inline.} =
-  self.godotVariant.asUInt()
-
-proc asInt*(self: Variant): int64 {.inline.} =
-  self.godotVariant.asInt()
-
-proc asReal*(self: Variant): cdouble {.inline.} =
-  self.godotVariant.asReal()
-
-proc asString*(self: Variant): string {.inline.} =
-  $self
-
-proc asVector2*(self: Variant): Vector2 {.inline.} =
-  self.godotVariant.asVector2()
-
-proc asRect2*(self: Variant): Rect2 {.inline.} =
-  self.godotVariant.asRect2()
-
-proc asVector3*(self: Variant): Vector3 {.inline.} =
-  self.godotVariant.asVector3()
-
-proc asTransform2D*(self: Variant): Transform2D {.inline.} =
-  self.godotVariant.asTransform2D()
-
-proc asPlane*(self: Variant): Plane {.inline.} =
-  self.godotVariant.asPlane()
-
-proc asQuat*(self: Variant): Quat {.inline.} =
-  self.godotVariant.asQuat()
-
-proc asAABB*(self: Variant): AABB {.inline.} =
-  self.godotVariant.asAABB()
-
-proc asBasis*(self: Variant): Basis {.inline.} =
-  self.godotVariant.asBasis()
-
-proc asTransform*(self: Variant): Transform {.inline.} =
-  self.godotVariant.asTransform()
-
-proc asColor*(self: Variant): Color {.inline.} =
-  self.godotVariant.asColor()
-
-proc asNodePath*(self: Variant): NodePath {.inline.} =
-  result = newNodePath(self.godotVariant.asNodePath())
-
-proc asRID*(self: Variant): RID {.inline.} =
-  self.godotVariant.asRID()
-
-proc asGodotObject*(self: Variant): ptr GodotObject {.inline.} =
-  self.godotVariant.asGodotObject()
-
-proc asPoolByteArray*(self: Variant): PoolByteArray {.inline.} =
-  newPoolByteArray(self.godotVariant.asGodotPoolByteArray())
-
-proc asPoolIntArray*(self: Variant): PoolIntArray {.inline.} =
-  newPoolIntArray(self.godotVariant.asGodotPoolIntArray())
-
-proc asPoolRealArray*(self: Variant): PoolRealArray {.inline.} =
-  newPoolRealArray(self.godotVariant.asGodotPoolRealArray())
-
-proc asPoolStringArray*(self: Variant): PoolStringArray {.inline.} =
-  newPoolStringArray(self.godotVariant.asGodotPoolStringArray())
-
-proc asPoolVector2Array*(self: Variant): PoolVector2Array {.inline.} =
-  newPoolVector2Array(self.godotVariant.asGodotPoolVector2Array())
-
-proc asPoolVector3Array*(self: Variant): PoolVector3Array {.inline.} =
-  newPoolVector3Array(self.godotVariant.asGodotPoolVector3Array())
-
-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)
-  s.deinit()
-
-proc `==`*(self, other: Variant): bool =
-  if self.isNil and other.isNil: return true
-  if self.isNil != other.isNil: return false
-  result = self.godotVariant == other.godotVariant
-
-proc `<`*(self, other: Variant): bool =
-  result = self.godotVariant < other.godotVariant
-
-proc hashCompare*(self, other: Variant): bool =
-  self.godotVariant.hashCompare(other.godotVariant)
-
-proc booleanize*(self: Variant): bool =
-  self.godotVariant.booleanize()

godot/core/vector2.nim

@@ -1,214 +1,117 @@
-# Copyright (c) 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
-import math, godotbase, hashes
+type
+  Vector2* {.importc: "godot_vector2", header: "godot/vector2.h",
+             byref.} = object
 
-import internal/godotinternaltypes, internal/godotstrings
-import godotcoretypes, gdnativeapi
+import godotbase, strings
 
-const EPSILON = 0.00001'f32
+proc initVector2(dest: var Vector2; x, y: float32) {.
+    importc: "godot_vector2_new", header: "godot/vector2.h".}
 
-{.push stackTrace: off.}
+proc vec2*(x, y: float32): Vector2 {.inline.} =
+  initVector2(result, x, y)
 
-proc vec2*(): Vector2 {.inline, noinit.} =
-  Vector2()
+proc toGodotString*(self: Vector2): GodotString {.
+    importc: "godot_vector2_as_string", header: "godot/vector2.h".}
+proc `$`*(self: Vector2): string {.inline.} =
+  $self.toGodotString()
 
-proc vec2*(x, y: float32): Vector2 {.inline, noinit.} =
-  Vector2(x: x, y: y)
+proc normalized*(self: Vector2): Vector2 {.
+    importc: "godot_vector2_normalized", header: "godot/vector2.h".}
+proc length*(self: Vector2): float32 {.
+    importc: "godot_vector2_length", header: "godot/vector2.h".}
+proc angle*(self: Vector2): float32 {.
+    importc: "godot_vector2_angle", header: "godot/vector2.h".}
+proc lengthSquared*(self: Vector2): float32 {.
+    importc: "godot_vector2_length_squared", header: "godot/vector2.h".}
+proc isNormalized*(self: Vector2): bool {.
+    importc: "godot_vector2_is_normalized", header: "godot/vector2.h".}
+proc distanceTo*(self, to: Vector2): float32 {.
+    importc: "godot_vector2_distance_to",
+    header: "godot/vector2.h".}
+proc distanceSquaredTo*(self, to: Vector2): float32 {.
+    importc: "godot_vector2_distance_squared_to",
+    header: "godot/vector2.h".}
+proc angleTo*(self, to: Vector2): float32 {.
+    importc: "godot_vector2_angle_to", header: "godot/vector2.h".}
+proc angleToPoint*(self, to: Vector2): float32 {.
+    importc: "godot_vector2_angle_to_point",
+    header: "godot/vector2.h".}
+proc lerp*(self, b: Vector2; t: float32): Vector2 {.
+    importc: "godot_vector2_linear_interpolate",
+    header: "godot/vector2.h".}
+proc cubicInterpolate*(self, b, pre_a, post_b: Vector2; t: float32): Vector2 {.
+    importc: "godot_vector2_cubic_interpolate",
+    header: "godot/vector2.h".}
+proc rotated*(self: Vector2; phi: float32): Vector2 {.
+    importc: "godot_vector2_rotated", header: "godot/vector2.h".}
+proc tangent*(self: Vector2): Vector2 {.
+    importc: "godot_vector2_tangent", header: "godot/vector2.h".}
+proc floor*(self: Vector2): Vector2 {.
+    importc: "godot_vector2_floor", header: "godot/vector2.h".}
+proc snapped*(self: Vector2; by: Vector2): Vector2 {.
+    importc: "godot_vector2_snapped", header: "godot/vector2.h".}
+proc aspect*(self: Vector2): float32 {.
+    importc: "godot_vector2_aspect", header: "godot/vector2.h".}
+proc dot*(a, b: Vector2): float32 {.
+    importc: "godot_vector2_dot", header: "godot/vector2.h".}
+proc slide*(self, n: Vector2): Vector2 {.
+    importc: "godot_vector2_slide", header: "godot/vector2.h".}
+proc bounce*(self, n: Vector2): Vector2 {.
+    importc: "godot_vector2_bounce", header: "godot/vector2.h".}
+proc reflect*(self, n: Vector2): Vector2 {.
+    importc: "godot_vector2_reflect", header: "godot/vector2.h".}
+proc abs*(self: Vector2): Vector2 {.
+    importc: "godot_vector2_abs", header: "godot/vector2.h".}
+proc clamped*(self: Vector2; length: float32): Vector2 {.
+    importc: "godot_vector2_clamped", header: "godot/vector2.h".}
 
-proc `$`*(self: Vector2): string {.inline, noinit.} =
-  $getGDNativeAPI().vector2AsString(self)
+proc `+`*(a, b: Vector2): Vector2 {.
+    importc: "godot_vector2_operator_add", header: "godot/vector2.h".}
+proc `+=`*(a: var Vector2, b: Vector2) {.inline.} =
+  a += b
 
-proc hash*(self: Vector2): Hash {.inline, noinit.} =
-  !$(self.x.hash() !& self.y.hash())
+proc `-`*(a, b: Vector2): Vector2 {.
+    importc: "godot_vector2_operator_substract", header: "godot/vector2.h".}
+proc `-=`*(a: var Vector2, b: Vector2) {.inline.} =
+  a = a - b
 
-proc `+`*(self, other: Vector2): Vector2 {.inline, noinit.} =
-  Vector2(x: self.x + other.x, y: self.y + other.y)
+proc `*`*(a, b: Vector2): Vector2 {.
+    importc: "godot_vector2_operator_multiply_vector",
+    header: "godot/vector2.h".}
 
-proc `+=`*(self: var Vector2, other: Vector2) {.inline, noinit.} =
-  self.x += other.x
-  self.y += other.y
+proc `*=`*(a: var Vector2, b: Vector2) {.inline.} =
+  a = a * b
 
-proc `-`*(self, other: Vector2): Vector2 {.inline, noinit.} =
-  Vector2(x: self.x - other.x, y: self.y - other.y)
+proc `*`*(self: Vector2, scalar: float32): Vector2 {.
+    importc: "godot_vector2_operator_multiply_scalar",
+    header: "godot/vector2.h".}
+proc `*=`*(self: var Vector2, scalar: float32) {.inline.} =
+  self = self * scalar
 
-proc `-=`*(self: var Vector2, other: Vector2) {.inline, noinit.} =
-  self.x -= other.x
-  self.y -= other.y
+proc `/`*(a, b: Vector2): Vector2 {.
+    importc: "godot_vector2_operator_divide_vector", header: "godot/vector2.h".}
+proc `/=`*(a: var Vector2, b: Vector2) {.inline.} =
+  a = a / b
 
-proc `*`*(self, other: Vector2): Vector2 {.inline, noinit.} =
-  Vector2(x: self.x * other.x, y: self.y * other.y)
-
-proc `*=`*(self: var Vector2, other: Vector2) {.inline, noinit.} =
-  self.x *= other.x
-  self.y *= other.y
-
-proc `*`*(self: Vector2, scalar: float32): Vector2 {.inline, noinit.} =
-  Vector2(x: self.x * scalar, y: self.y * scalar)
-
-proc `*`*(scalar: float32, v: Vector2): Vector2 {.inline, noinit.} =
-  v * scalar
-
-proc `*=`*(self: var Vector2, scalar: float32) {.inline, noinit.} =
-  self.x *= scalar
-  self.y *= scalar
-
-proc `/`*(self, other: Vector2): Vector2 {.inline, noinit.} =
-  Vector2(x: self.x / other.x, y: self.y / other.y)
-
-proc `/=`*(self: var Vector2, other: Vector2) {.inline, noinit.} =
-  self.x /= other.x
-  self.y /= other.y
-
-proc `/`*(self: Vector2; scalar: float32): Vector2 {.inline, noinit.} =
-  Vector2(x: self.x / scalar, y: self.y / scalar)
-
-proc `/=`*(self: var Vector2; scalar: float32) {.inline, noinit.} =
+proc `/`*(self: Vector2; scalar: float32): Vector2 {.
+    importc: "godot_vector2_operator_divide_scalar", header: "godot/vector2.h".}
+proc `/=`*(self: var Vector2; scalar: float32) {.inline.} =
   self = self / scalar
 
-proc `==`*(self, other: Vector2): bool {.inline, noinit.} =
-  self.x == other.x and self.y == other.y
+proc `==`*(a, b: Vector2): bool {.
+    importc: "godot_vector2_operator_equal", header: "godot/vector2.h".}
+proc `<`*(a, b: Vector2): bool {.
+    importc: "godot_vector2_operator_less", header: "godot/vector2.h".}
+proc `-`*(self: Vector2): Vector2 {.
+    importc: "godot_vector2_operator_neg", header: "godot/vector2.h".}
 
-proc `<`*(self, other: Vector2): bool {.inline, noinit.} =
-  if self.x == other.x:
-    self.y < other.y
-  else:
-    self.x < other.x
-
-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
+proc `x=`*(self: var Vector2; x: float32) {.
+    importc: "godot_vector2_set_x", header: "godot/vector2.h".}
+proc `y=`*(self: var Vector2; y: float32) {.
+    importc: "godot_vector2_set_y", header: "godot/vector2.h".}
+proc x*(self: Vector2): float32 {.
+    importc: "godot_vector2_get_x", header: "godot/vector2.h".}
+proc y*(self: Vector2): float32 {.
+    importc: "godot_vector2_get_y", header: "godot/vector2.h".}

godot/core/vector3.nim

@@ -1,254 +1,148 @@
-# Copyright (c) 2018 Xored Software, Inc.
+# Copyright (c) 2017 Xored Software, Inc.
 
-import math, hashes
-import godotbase, godotcoretypes
+type
+  Vector3* {.importc: "godot_vector3", header: "godot/vector3.h",
+             byref.} = object
 
-const EPSILON = 0.00001'f32
+import godotbase, basis, strings
 
-{.push stackTrace: off.}
+type
+  Vector3Axis {.importc: "godot_vector3_axis", header: "godot/vector3.h",
+                size: sizeof(cint), pure.} = enum
+    X,
+    Y,
+    Z
 
-proc vec3*(): Vector3 {.inline.} =
-  Vector3()
+proc initVector3*(dest: var Vector3; x, y, z: float32) {.
+    importc: "godot_vector3_new", header: "godot/vector3.h".}
 
 proc vec3*(x, y, z: float32): Vector3 {.inline.} =
-  Vector3(x: x, y: y, z: z)
+  initVector3(result, x, y, z)
 
+proc toGodotString*(self: Vector3): GodotString {.
+    importc: "godot_vector3_as_string", header: "godot/vector3.h".}
 proc `$`*(self: Vector3): string {.inline.} =
-  result = newStringOfCap(40)
-  result.add('(')
-  result.add($self.x)
-  result.add(", ")
-  result.add($self.y)
-  result.add(", ")
-  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
-  result.z = a.z + b.z
-
-proc `+=`*(a: var Vector3, b: Vector3) {.inline.} =
-  a.x += b.x
-  a.y += b.y
-  a.z += b.z
-
-proc `-`*(a, b: Vector3): Vector3 {.inline.} =
-  result.x = a.x - b.x
-  result.y = a.y - b.y
-  result.z = a.z - b.z
-
-proc `-=`*(a: var Vector3, b: Vector3) {.inline.} =
-  a.x -= b.x
-  a.y -= b.y
-  a.z -= b.z
-
-proc `*`*(a, b: Vector3): Vector3 {.inline.} =
-  result.x = a.x * b.x
-  result.y = a.y * b.y
-  result.z = a.z * b.z
-
-proc `*=`*(a: var Vector3, b: Vector3) {.inline.}=
-  a.x *= b.x
-  a.y *= b.y
-  a.z *= b.z
-
-proc `*`*(a: Vector3; b: float32): Vector3 {.inline.} =
-  result.x = a.x * b
-  result.y = a.y * b
-  result.z = a.z * b
-
-proc `*`*(b: float32; a: Vector3): Vector3 {.inline.} =
-  a * b
-
-proc `*=`*(a: var Vector3; b: float32) {.inline.} =
-  a.x *= b
-  a.y *= b
-  a.z *= b
-
-proc `/`*(a, b: Vector3): Vector3 =
-  result.x = a.x / b.x
-  result.y = a.y / b.y
-  result.z = a.z / b.z
-
-proc `/=`*(a: var Vector3; b: Vector3) {.inline.} =
-  a.x /= b.x
-  a.y /= b.y
-  a.z /= b.z
-
-proc `/`*(a: Vector3; b: float32): Vector3 =
-  result.x = a.x / b
-  result.y = a.y / b
-  result.z = a.z / b
-
-proc `/=`*(a: var Vector3; b: float32) {.inline.} =
-  a.x /= b
-  a.y /= b
-  a.z /= b
-
-proc `==`*(a, b: Vector3): bool {.inline.} =
-  a.x == b.x and a.y == b.y and a.z == b.z
-
-proc `<`*(a, b: Vector3): bool =
-  if a.x == b.x:
-    if a.y == b.y:
-      return a.z < b.z
-    return a.y < b.y
-  return a.x < b.x
-
-proc `-`*(self: Vector3): Vector3 =
-  result.x = -self.x
-  result.y = -self.y
-  result.z = -self.z
-
-proc `[]`*(self: Vector3, idx: range[0..2]): float32 {.inline.} =
-  cast[array[3, float32]](self)[idx]
-
-proc `[]`*(self: var Vector3, idx: range[0..2]): var float32 {.inline.} =
-  cast[ptr array[3, float32]](addr self)[][idx]
-
-proc `[]=`*(self: var Vector3, idx: range[0..2],
-            val: float32) {.inline.} =
-  case idx:
-  of 0: self.x = val
-  of 1: self.y = val
-  of 2: self.z = val
-
-proc minAxis*(self: Vector3): int {.inline.} =
-  if self.x < self.y:
-    if self.x < self.z: 0 else: 2
-  else:
-    if self.y < self.z: 1 else: 2
-
-proc maxAxis*(self: Vector3): int {.inline.} =
-  if self.x < self.y:
-    if self.y < self.z: 2 else: 1
-  else:
-    if self.x < self.z: 2 else: 0
-
-proc length*(self: Vector3): float32 {.inline.} =
-  let x2 = self.x * self.x
-  let y2 = self.y * self.y
-  let z2 = self.z * self.z
-
-  result = sqrt(x2 + y2 + z2)
-
-proc lengthSquared*(self: Vector3): float32 {.inline.} =
-  let x2 = self.x * self.x
-  let y2 = self.y * self.y
-  let z2 = self.z * self.z
-
-  result = x2 + y2 + z2
-
-proc normalize*(self: var Vector3) {.inline.} =
-  let len = self.length()
-  if len == 0:
-    self.x = 0
-    self.y = 0
-    self.z = 0
-  else:
-    self.x /= len
-    self.y /= len
-    self.z /= len
-
-proc normalized*(self: Vector3): Vector3 {.inline.} =
-  result = self
-  result.normalize()
-
-proc isNormalized*(self: Vector3): bool {.inline.} =
-  self.lengthSquared().isEqualApprox(1.0'f32)
-
-proc zero*(self: var Vector3) {.inline.} =
-  self.x = 0
-  self.y = 0
-  self.z = 0
-
-proc inverse*(self: Vector3): Vector3 {.inline.} =
-  vec3(1.0'f32 / self.x, 1.0'f32 / self.y, 1.0'f32 / self.z)
-
-proc cross*(self, other: Vector3): Vector3 {.inline.} =
-  vec3(
-    self.y * other.z - self.z * other.y,
-    self.z * other.x - self.x * other.z,
-    self.x * other.y - self.y * other.x)
-
-proc dot*(self, other: Vector3): float32 {.inline.} =
-  self.x * other.x + self.y * other.y + self.z * other.z
-
-proc abs*(self: Vector3): Vector3 {.inline.} =
-  vec3(abs(self.x), abs(self.y), abs(self.z))
-
-proc sign*(self: Vector3): Vector3 {.inline.} =
-  vec3(sign(self.x),  sign(self.y), sign(self.z))
-
-proc floor*(self: Vector3): Vector3 {.inline.} =
-  vec3(floor(self.x), floor(self.y), floor(self.z))
-
-proc ceil*(self: Vector3): Vector3 {.inline.} =
-  vec3(ceil(self.x), ceil(self.y), ceil(self.z))
-
-proc lerp*(self: Vector3, other: Vector3, t: float32): Vector3 {.inline.} =
-  vec3(
-    self.x + t * (other.x - self.x),
-    self.y + t * (other.y - self.y),
-    self.z + t * (other.z - self.z)
-  )
-
-proc distanceTo*(self, other: Vector3): float32 {.inline.} =
-  (other - self).length()
-
-proc distanceSquaredTo*(self, other: Vector3): float32 {.inline.} =
-  (other - self).lengthSquared()
-
-proc angleTo*(self, other: Vector3): float32 {.inline.} =
-  arctan2(self.cross(other).length(), self.dot(other))
-
-proc slide*(self, n: Vector3): Vector3 {.inline.} =
-  assert(n.isNormalized())
-  result = self - n * self.dot(n)
-
-proc reflect*(self, n: Vector3): Vector3 {.inline.} =
-  assert(n.isNormalized())
-  result = 2.0'f32 * n * self.dot(n) - self
-
-proc bounce*(self, n: Vector3): Vector3 {.inline.} =
-  -self.reflect(n)
-
-proc snap*(self: var Vector3, other: Vector3) =
-  self.x = stepify(self.x, other.x)
-  self.y = stepify(self.y, other.y)
-  self.z = stepify(self.z, other.z)
-
-proc snapped*(self: Vector3, other: Vector3): Vector3 =
-  result = self
-  result.snap(other)
+  $self.toGodotString()
 
+proc minAxis*(self: Vector3): cint {.
+    importc: "godot_vector3_min_axis", header: "godot/vector3.h".}
+proc maxAxis*(self: Vector3): cint {.
+    importc: "godot_vector3_max_axis", header: "godot/vector3.h".}
+proc length*(self: Vector3): float32 {.
+    importc: "godot_vector3_length", header: "godot/vector3.h".}
+proc lengthSquared*(self: Vector3): float32 {.
+    importc: "godot_vector3_length_squared", header: "godot/vector3.h".}
+proc isNormalized*(self: Vector3): bool {.
+    importc: "godot_vector3_is_normalized", header: "godot/vector3.h".}
+proc normalized*(self: Vector3): Vector3 {.
+    importc: "godot_vector3_normalized", header: "godot/vector3.h".}
+proc inverse*(self: Vector3): Vector3 {.
+    importc: "godot_vector3_inverse", header: "godot/vector3.h".}
+proc snapped*(self: Vector3; by: float32): Vector3 {.
+    importc: "godot_vector3_snapped", header: "godot/vector3.h".}
+proc rotated*(self: Vector3; axis: Vector3;
+              phi: float32): Vector3 {.
+    importc: "godot_vector3_rotated", header: "godot/vector3.h".}
+proc lerp*(self: Vector3; b: Vector3; t: float32): Vector3 {.
+    importc: "godot_vector3_linear_interpolate", header: "godot/vector3.h".}
 proc cubicInterpolate*(self, b, preA, postB: Vector3;
-                       t: float32): Vector3 =
-  let p0 = preA
-  let p1 = self
-  let p2 = b
-  let p3 = postB
+                       t: float32): Vector3 {.
+    importc: "godot_vector3_cubic_interpolate", header: "godot/vector3.h".}
+proc dot*(a, b: Vector3): float32 {.
+    importc: "godot_vector3_dot", header: "godot/vector3.h".}
+proc cross*(a, b: Vector3): Vector3 {.
+    importc: "godot_vector3_cross", header: "godot/vector3.h".}
+proc outer*(a, b: Vector3): Basis {.
+    importc: "godot_vector3_outer", header: "godot/vector3.h".}
+proc toDiagonalMatrix*(self: Vector3): Basis {.
+    importc: "godot_vector3_to_diagonal_matrix", header: "godot/vector3.h".}
+proc abs*(self: Vector3): Vector3 {.
+    importc: "godot_vector3_abs", header: "godot/vector3.h".}
+proc floor*(self: Vector3): Vector3 {.
+    importc: "godot_vector3_floor", header: "godot/vector3.h".}
+proc ceil*(self: Vector3): Vector3 {.
+    importc: "godot_vector3_ceil", header: "godot/vector3.h".}
+proc distanceTo*(a, b: Vector3): float32 {.
+    importc: "godot_vector3_distance_to", header: "godot/vector3.h".}
+proc distanceSquaredTo*(a, b: Vector3): float32 {.
+    importc: "godot_vector3_distance_squared_to", header: "godot/vector3.h".}
+proc angleTo*(self, to: Vector3): float32 {.
+    importc: "godot_vector3_angle_to", header: "godot/vector3.h".}
+proc slide*(self, n: Vector3): Vector3 {.
+    importc: "godot_vector3_slide", header: "godot/vector3.h".}
+proc bounce*(self, n: Vector3): Vector3 {.
+    importc: "godot_vector3_bounce", header: "godot/vector3.h".}
+proc reflect*(self, b: Vector3): Vector3 {.
+    importc: "godot_vector3_reflect", header: "godot/vector3.h".}
 
-  let t2 = t * t
-  let t3 = t2 * t
+proc `+`*(a, b: Vector3): Vector3 {.
+    importc: "godot_vector3_operator_add", header: "godot/vector3.h".}
+proc `+=`*(a: var Vector3, b: Vector3) {.inline.} =
+  a = a + b
 
-  result = 0.5 * ((p1 * 2.0) +
-            (-p0 + p2) * t +
-            (2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 +
-            (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3)
+proc `-`*(a, b: Vector3): Vector3 {.
+    importc: "godot_vector3_operator_substract", header: "godot/vector3.h".}
+proc `-=`*(a: var Vector3, b: Vector3) {.inline.} =
+  a = a - b
 
-proc moveToward*(vFrom, to: Vector3, delta: float32): Vector3 =
-  let
-    vd = to - vFrom
-    vLen = vd.length
+proc `*`*(a, b: Vector3): Vector3 {.
+    importc: "godot_vector3_operator_multiply_vector",
+    header: "godot/vector3.h".}
+proc `*=`*(a: var Vector3, b: Vector3) {.inline.}=
+  a = a * b
 
-  if vLen <= delta or vLen < EPSILON:
-    result = to
-  else:
-    result = vFrom + (vd / vLen) * delta
+proc `*`*(self: Vector3; b: float32): Vector3 {.
+    importc: "godot_vector3_operator_multiply_scalar",
+    header: "godot/vector3.h".}
+proc `*=`*(a: var Vector3; b: float32) {.inline.} =
+  a = a * b
 
-{.pop.} # stackTrace: off
+proc `/`*(a, b: Vector3): Vector3 {.
+    importc: "godot_vector3_operator_divide_vector",
+    header: "godot/vector3.h".}
+proc `/=`*(a: var Vector3; b: Vector3) {.inline.} =
+  a = a / b
+
+proc `/`*(self: Vector3; b: float32): Vector3 {.
+    importc: "godot_vector3_operator_divide_scalar",
+    header: "godot/vector3.h".}
+proc `/=`*(a: var Vector3; b: float32) {.inline.} =
+  a = a / b
+
+proc `==`*(a, b: Vector3): bool {.
+    importc: "godot_vector3_operator_equal", header: "godot/vector3.h".}
+proc `<`*(a, b: Vector3): bool {.
+    importc: "godot_vector3_operator_less", header: "godot/vector3.h".}
+proc `-`*(self: Vector3): Vector3 {.
+    importc: "godot_vector3_operator_neg", header: "godot/vector3.h".}
+
+proc setAxis(self: var Vector3; axis: Vector3Axis;
+             val: float32) {.
+    importc: "godot_vector3_set_axis", header: "godot/vector3.h".}
+proc getAxis(self: Vector3; axis: Vector3Axis): float32 {.
+    importc: "godot_vector3_get_axis", header: "godot/vector3.h".}
+
+proc `[]`(self: Vector3, idx: range[0..2]): float32 {.inline.} =
+  self.getAxis(Vector3Axis(idx))
+
+proc `[]=`(self: var Vector3, idx: range[0..2],
+           val: float32): float32 {.inline.} =
+  self.setAxis(Vector3Axis(idx), val)
+
+proc x*(self: Vector3): float32 {.inline.} =
+  self.getAxis(Vector3Axis.X)
+
+proc `x=`*(self: var Vector3, val: float32) {.inline.} =
+  self.setAxis(Vector3Axis.X, val)
+
+proc y*(self: Vector3): float32 {.inline.} =
+  self.getAxis(Vector3Axis.Y)
+
+proc `y=`*(self: var Vector3, val: float32) {.inline.} =
+  self.setAxis(Vector3Axis.Y, val)
+
+proc z*(self: Vector3): float32 {.inline.} =
+  self.getAxis(Vector3Axis.Z)
+
+proc `z=`*(self: var Vector3, val: float32) {.inline.} =
+  self.setAxis(Vector3Axis.Z, val)

godot/godot.nim

@@ -1,18 +1,16 @@
-# Copyright 2018 Xored Software, Inc.
+# Copyright 2017 Xored Software, Inc.
 
-import core/godotbase, godotinternal
-import core/godotcoretypes
-import core/vector2, core/rect2, core/vector3, core/transform2d, core/planes,
-       core/quats
-import core/aabb, core/basis, core/transforms, core/colors, core/nodepaths,
-       core/rids
-import core/dictionaries, core/arrays, core/poolarrays, core/variants
+import core.godotbase, core.godotcore
+import core / [strings, vector2, rect2, vector3, transform2d, plane, quat]
+import core / [rect3, basis, transform, color, nodepath, rid]
+import core / [dictionary, arrays, poolarray, variant]
 
-import nim/godotmacros, nim/godotnim
+import nim / [godotmacros, godotnim]
 
-export godotbase, godotcoretypes, vector2, rect2, vector3, transform2d, planes,
-       quats, aabb, basis, transforms, colors, nodepaths, rids, dictionaries,
-       arrays, poolarrays, variants
+export godotbase, strings, vector2, rect2, vector3, transform2d, plane, quat,
+       rect3, basis, transform, color, nodepath, rid, dictionary, arrays,
+       poolarray, variant
 export godotmacros, godotnim
 
-export GodotPropertyHint, GodotPropertyUsage
+# from godotcore
+export print, printWarning, printError

godot/godot.nim.cfg

@@ -1,2 +0,0 @@
---path:"$projectdir"
--d:useRealtimeGc

godot/godotinternal.nim

@@ -1,122 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import internal/godotinternaltypes, internal/godotarrays,
-       internal/godotnodepaths, internal/godotpoolarrays, internal/godotstrings,
-       internal/godotvariants, internal/godotdictionaries
-
-import gdnativeapi
-export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays,
-       godotstrings, godotvariants, godotdictionaries
-
-proc getMethod*(className: cstring;
-                methodName: cstring): ptr GodotMethodBind {.inline.} =
-  getGDNativeAPI().methodBindGetMethod(className, methodName)
-
-proc ptrCall*(methodBind: ptr GodotMethodBind;
-              instance: ptr GodotObject;
-              args: ptr array[MAX_ARG_COUNT, pointer];
-              ret: pointer) {.inline.} =
-  getGDNativeAPI().methodBindPtrCall(methodBind, instance, args, ret)
-
-proc call*(methodBind: ptr GodotMethodBind;
-           instance: ptr GodotObject;
-           args: ptr array[MAX_ARG_COUNT, ptr GodotVariant]; argCount: cint;
-           callError: var VariantCallError): GodotVariant {.inline.} =
-  getGDNativeAPI().methodBindCall(
-    methodBind, instance, args, argCount, callError)
-
-proc nativeScriptRegisterClass*(libHandle: pointer; name, base: cstring;
-                                createFunc: GodotInstanceCreateFunc;
-                                destroyFunc: GodotInstanceDestroyFunc)
-                               {.inline.} =
-  getGDNativeAPI().nativeScriptRegisterClass(
-    libHandle, name, base, createFunc, destroyFunc)
-
-proc nativeScriptRegisterToolClass*(libHandle: pointer; name, base: cstring;
-                                    createFunc: GodotInstanceCreateFunc;
-                                    destroyFunc: GodotInstanceDestroyFunc)
-                                   {.inline.} =
-  getGDNativeAPI().nativeScriptRegisterToolClass(
-    libHandle, name, base, createFunc, destroyFunc)
-
-proc nativeScriptRegisterMethod*(libHandle: pointer;
-                                 name: cstring; function_name: cstring;
-                                 attr: GodotMethodAttributes;
-                                 meth: GodotInstanceMethod) {.inline.} =
-  getGDNativeAPI().nativeScriptRegisterMethod(
-    libHandle, name, functionName, attr, meth)
-
-proc nativeScriptRegisterProperty*(libHandle: pointer;
-                                   name, path: cstring;
-                                   attr: ptr GodotPropertyAttributes;
-                                   setFunc: GodotPropertySetFunc;
-                                   getFunc: GodotPropertyGetFunc) {.inline.} =
-  getGDNativeAPI().nativeScriptRegisterProperty(
-    libHandle, name, path, attr, setFunc, getFunc)
-
-proc nativeScriptRegisterSignal*(libHandle: pointer; name: cstring;
-                                 signal: GodotSignal) {.inline.} =
-  getGDNativeAPI().nativeScriptRegisterSignal(libHandle, name, signal)
-
-proc getUserdata*(instance: ptr GodotObject): pointer {.inline.} =
-  getGDNativeAPI().nativeScriptGetUserdata(instance)
-
-proc getClassConstructor*(className: cstring): GodotClassConstructor
-                         {.inline.} =
-  getGDNativeAPI().getClassConstructor(className)
-
-proc deinit*(o: ptr GodotObject) {.inline.} =
-  getGDNativeAPI().objectDestroy(o)
-
-# print using Godot's error handler list
-
-proc godotPrintError*(description, function, file: cstring;
-                      line: cint) {.inline.} =
-  getGDNativeAPI().printError(description, function, file, line)
-
-proc godotPrintWarning*(description, function, file: cstring;
-                        line: cint) {.inline.} =
-  getGDNativeAPI().printWarning(description, function, file, line)
-
-proc godotPrint*(message: GodotString) {.inline.} =
-  getGDNativeAPI().print(message)
-
-var getClassMethodBind: ptr GodotMethodBind
-proc getClassName*(o: ptr GodotObject): string =
-  if getClassMethodBind.isNil:
-    getClassMethodBind = getMethod(cstring"Object", cstring"get_class")
-  var ret: GodotString
-  getClassMethodBind.ptrCall(o, nil, addr ret)
-  result = $ret
-  deinit(ret)
-  if result.len > 2 and result[^2] == 'S' and result[^1] == 'W':
-    # There are physics type not known by ClassDB
-    result = result[0..result.len-3]
-
-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)
-
-# System Functions
-
-proc godotAlloc*(bytes: cint): pointer {.inline.} =
-  ## Allocates the specified number of bytes.
-  ## Using this instead of stdlib proc will help Godot track how much memory
-  ## is in use in debug mode.
-  getGDNativeAPI().alloc(bytes)
-
-proc godotRealloc*(p: pointer; bytes: cint): pointer {.inline.} =
-  ## Reallocates the pointer for the specified number of bytes.
-  ## Using this instead of stdlib proc will help Godot track how much memory
-  ## is in use in debug mode.
-  getGDNativeAPI().realloc(p, bytes)
-
-proc godotFree*(p: pointer) {.inline.} =
-  ## Frees the memory pointed to by the pointer.
-  ## Using this instead of stdlib proc will help Godot track how much memory
-  ## is in use in debug mode.
-  getGDNativeAPI().free(p)

godot/internal/backwardcompat.inc.nim

@@ -1,19 +0,0 @@
-# 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]()

godot/internal/godotarrays.nim

@@ -1,162 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import godotinternaltypes, gdnativeapi, core/godotcoretypes
-
-proc len*(self: GodotArray): cint {.inline.} =
-  getGDNativeAPI().arraySize(self)
-
-import hashes
-
-proc initGodotArray*(dest: var GodotArray) {.inline.} =
-  getGDNativeAPI().arrayNew(dest)
-
-proc initGodotArray*(dest: var GodotArray;
-                     pca: GodotPoolColorArray) {.inline.} =
-  getGDNativeAPI().arrayNewPoolColorArray(dest, pca)
-
-proc initGodotArray*(dest: var GodotArray;
-                     pv3a: GodotPoolVector3Array) {.inline.} =
-  getGDNativeAPI().arrayNewPoolVector3Array(dest, pv3a)
-
-proc initGodotArray*(dest: var GodotArray;
-                     pv2a: GodotPoolVector2Array) {.inline.} =
-  getGDNativeAPI().arrayNewPoolVector2Array(dest, pv2a)
-
-proc initGodotArray*(dest: var GodotArray;
-                     psa: GodotPoolStringArray) {.inline.} =
-  getGDNativeAPI().arrayNewPoolStringArray(dest, psa)
-
-proc initGodotArray*(dest: var GodotArray;
-                     pra: GodotPoolRealArray) {.inline.} =
-  getGDNativeAPI().arrayNewPoolRealArray(dest, pra)
-
-proc initGodotArray*(dest: var GodotArray;
-                     pia: GodotPoolIntArray) {.inline.} =
-  getGDNativeAPI().arrayNewPoolIntArray(dest, pia)
-
-proc initGodotArray*(dest: var GodotArray;
-                     pba: GodotPoolByteArray) {.inline.} =
-  getGDNativeAPI().arrayNewPoolByteArray(dest, pba)
-
-proc initGodotArray*(dest: var GodotArray; src: GodotArray) {.inline.} =
-  getGDNativeAPI().arrayNewCopy(dest, src)
-
-proc deinit*(self: var GodotArray) {.inline.} =
-  getGDNativeAPI().arrayDestroy(self)
-
-proc `[]=`*(self: var GodotArray; idx: cint; value: GodotVariant) {.inline.} =
-  getGDNativeAPI().arraySet(self, idx, value)
-
-proc `[]`*(self: GodotArray; idx: cint): GodotVariant {.inline.} =
-  getGDNativeAPI().arrayGet(self, idx)
-
-proc mget*(self: var GodotArray; idx: cint): ptr GodotVariant {.inline.} =
-  getGDNativeAPI().arrayOperatorIndex(self, idx)
-
-proc add*(self: var GodotArray; value: GodotVariant) {.inline.} =
-  getGDNativeAPI().arrayPushBack(self, value)
-
-proc clear*(self: var GodotArray) {.inline.} =
-  getGDNativeAPI().arrayClear(self)
-
-proc count*(self: GodotArray; value: GodotVariant): cint {.inline.} =
-  getGDNativeAPI().arrayCount(self, value)
-
-proc isEmpty*(self: GodotArray): bool {.inline.} =
-  getGDNativeAPI().arrayEmpty(self)
-
-proc erase*(self: var GodotArray; value: GodotVariant) {.inline.} =
-  getGDNativeAPI().arrayErase(self, value)
-
-proc first*(self: GodotArray): GodotVariant {.inline.} =
-  getGDNativeAPI().arrayFront(self)
-
-proc last*(self: GodotArray): GodotVariant {.inline.} =
-  getGDNativeAPI().arrayBack(self)
-
-proc find*(self: GodotArray; what: GodotVariant;
-           fromIdx: cint): cint {.inline.} =
-  getGDNativeAPI().arrayFind(self, what, fromIdx)
-
-proc findLast*(self: GodotArray; what: GodotVariant): cint {.inline.} =
-  getGDNativeAPI().arrayFindLast(self, what)
-
-proc contains*(self: GodotArray; value: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().arrayHas(self, value)
-
-proc godotHash*(self: GodotArray): cint {.inline.} =
-  getGDNativeAPI().arrayHash(self)
-
-proc hash*(self: GodotArray): Hash {.inline.} =
-  hash(godotHash(self))
-
-proc insert*(self: var GodotArray; pos: cint;
-             value: GodotVariant): Error {.discardable, inline.} =
-  getGDNativeAPI().arrayInsert(self, pos, value)
-
-proc reverse*(self: var GodotArray) {.inline.} =
-  getGDNativeAPI().arrayInvert(self)
-
-proc popLast*(self: var GodotArray): GodotVariant {.inline.} =
-  getGDNativeAPI().arrayPopBack(self)
-
-proc popFirst*(self: var GodotArray): GodotVariant {.inline.} =
-  getGDNativeAPI().arrayPopFront(self)
-
-proc addLast*(self: var GodotArray; value: GodotVariant) {.inline.} =
-  getGDNativeAPI().arrayPushBack(self, value)
-
-proc addFirst*(self: var GodotArray; value: GodotVariant) {.inline.} =
-  getGDNativeAPI().arrayPushFront(self, value)
-
-proc delete*(self: var GodotArray; idx: cint) {.inline.} =
-  getGDNativeAPI().arrayRemove(self, idx)
-
-proc setLen*(self: var GodotArray; size: cint) {.inline.} =
-  getGDNativeAPI().arrayResize(self, size)
-
-proc rfind*(self: GodotArray; what: GodotVariant;
-            fromIdx: cint): cint {.inline.} =
-  getGDNativeAPI().arrayRFind(self, what, fromIdx)
-
-proc sort*(self: var GodotArray) {.inline.} =
-  getGDNativeAPI().arraySort(self)
-
-proc sortCustom*(self: var GodotArray; obj: ptr GodotObject;
-                 funcName: GodotString) {.inline.} =
-  getGDNativeAPI().arraySortCustom(self, obj, funcName)
-
-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.cint..<self.len:
-    yield self[i]
-
-iterator mitems*(self: var GodotArray): var GodotVariant =
-  for i in 0.cint..<self.len:
-    yield self.mget(i)[]
-
-iterator pairs*(self: GodotArray): tuple[key: cint, val: GodotVariant] =
-  for i in 0.cint..<self.len:
-    yield (i, self[i])
-
-iterator mpairs*(self: var GodotArray): tuple[key: cint,
-                                              val: var GodotVariant] =
-  for i in 0.cint..<self.len:
-    yield (i, self.mget(i)[])
-
-proc `$`*(self: GodotArray): string =
-  result = newStringOfCap(32)
-  result.add('[')
-  for item in self:
-    if result.len > 1:
-      result.add(", ")
-    result.add($item)
-  result.add(']')

godot/internal/godotdictionaries.nim

@@ -1,56 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import godotinternaltypes, gdnativeapi
-
-proc initGodotDictionary*(dest: var GodotDictionary) {.inline.} =
-  getGDNativeAPI().dictionaryNew(dest)
-
-proc initGodotDictionary*(dest: var GodotDictionary;
-                          src: GodotDictionary) {.inline.} =
-  getGDNativeAPI().dictionaryNewCopy(dest, src)
-
-proc deinit*(self: var GodotDictionary) {.inline.} =
-  getGDNativeAPI().dictionaryDestroy(self)
-
-proc len*(self: GodotDictionary): cint {.inline.} =
-  getGDNativeAPI().dictionarySize(self)
-
-proc isEmpty*(self: GodotDictionary): bool {.inline.} =
-  getGDNativeAPI().dictionaryEmpty(self)
-
-proc clear*(self: var GodotDictionary) {.inline.} =
-  getGDNativeAPI().dictionaryClear(self)
-
-proc contains*(self: GodotDictionary; key: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().dictionaryHas(self, key)
-
-proc contains*(self: GodotDictionary; keys: GodotArray): bool {.inline.} =
-  getGDNativeAPI().dictionaryHasAll(self, keys)
-
-proc del*(self: var GodotDictionary; key: GodotVariant) {.inline.} =
-  getGDNativeAPI().dictionaryErase(self, key)
-
-proc godotHash*(self: GodotDictionary): cint {.inline.} =
-  getGDNativeAPI().dictionaryHash(self, )
-
-proc keys*(self: GodotDictionary): GodotArray {.inline.} =
-  getGDNativeAPI().dictionaryKeys(self)
-
-proc values*(self: GodotDictionary): GodotArray {.inline.} =
-  getGDNativeAPI().dictionaryValues(self)
-
-proc `[]`*(self: GodotDictionary; key: GodotVariant): GodotVariant {.inline.} =
-  getGDNativeAPI().dictionaryGet(self, key)
-
-proc `[]=`*(self: var GodotDictionary; key, value: GodotVariant) {.inline.} =
-  getGDNativeAPI().dictionarySet(self, key, value)
-
-proc mget*(self: var GodotDictionary;
-           key: GodotVariant): ptr GodotVariant {.inline.} =
-  getGDNativeAPI().dictionaryOperatorIndex(self, key)
-
-proc `==`*(self, other: GodotDictionary): bool {.inline.} =
-  getGDNativeAPI().dictionaryOperatorEqual(self, other)
-
-proc toJson*(self: GodotDictionary): GodotString {.inline.} =
-  getGDNativeAPI().dictionaryToJson(self)

godot/internal/godotinternaltypes.nim

@@ -1,313 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-const MAX_ARG_COUNT* = 256
-
-type
-  GodotArray* {.byref.} = object
-    data: array[sizeof(int), byte]
-
-  GodotDictionary* {.byref.} = object
-    data: array[sizeof(int), byte]
-
-  GodotNodePath* {.byref.} = object
-    data: array[sizeof(int), byte]
-
-  GodotObject* = object
-
-  GodotPoolByteArray* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolByteArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolByteArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotPoolIntArray* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolIntArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolIntArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotPoolRealArray* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolRealArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolRealArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotPoolStringArray* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolStringArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolStringArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotPoolVector2Array* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolVector2ArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolVector2ArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotPoolVector3Array* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolVector3ArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolVector3ArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotPoolColorArray* {.byref.} = object
-    data: array[sizeof(int), byte]
-  GodotPoolColorArrayReadAccess* {.byref.} = object
-    data: array[1, byte]
-  GodotPoolColorArrayWriteAccess* {.byref.} = object
-    data: array[1, byte]
-
-  GodotString* {.byref.} = object
-    data: array[sizeof(int), byte]
-
-  cwchar_t* {.importc: "wchar_t", nodecl.} = object
-
-  GodotCharString* {.byref.} = object
-    data: array[sizeof(int), byte]
-
-  VariantType* {.size: sizeof(cint), pure.} = enum
-    Nil,   ##  atomic types
-    Bool,
-    Int,
-    Real,
-    String,
-    # math types
-    Vector2, ##  5
-    Rect2,
-    Vector3,
-    Transform2D,
-    Plane,
-    Quat, ##  10
-    AABB,
-    Basis,
-    Transform, ##  misc types
-    Color,
-    NodePath, ##  15
-    RID,
-    Object,
-    Dictionary,
-    Array, ##  20
-    # arrays
-    PoolByteArray,
-    PoolIntArray,
-    PoolRealArray,
-    PoolStringArray,
-    PoolVector2Array, ##  25
-    PoolVector3Array,
-    PoolColorArray
-
-  VariantCallErrorType* {.size: sizeof(cint), pure.} = enum
-    OK,
-    InvalidMethod,
-    InvalidArgument,
-    TooManyArguments,
-    TooFewArguments,
-    InstanceIsNull
-
-  VariantCallError* = object
-    error*: VariantCallErrorType
-    argument*: cint
-    expected*: VariantType
-
-  GodotVariant* {.byref.} = object
-    data: array[2, int64]
-    data2: int
-
-type GodotMethodBind* = object
-
-type
-  GDNativeAPIVersion* = object
-    major*: cuint
-    minor*: cuint
-
-  GDNativeInitOptions* = object
-    inEditor*: bool
-    coreApiHash*: uint64
-    editorApiHash*: uint64
-    noApiHash*: uint64
-    reportVersionMismatch*: proc (library: ptr GodotObject, extension: cstring,
-                                  want: GDNativeAPIVersion, have: GDNativeAPIVersion) {.noconv.}
-    reportLoadingError*: proc (library: ptr GodotObject, what: cstring) {.noconv.}
-    gdNativeLibrary*: ptr GodotObject
-    gdNativeAPIStruct*: pointer
-    activeLibraryPath*: ptr GodotString
-
-  GDNativeTerminateOptions* = object
-    inEditor*: bool
-
-  GodotMethodRPCMode* {.size: sizeof(cint), pure.} = enum
-    Disabled,
-    Remote,
-    Sync,
-    Master,
-    Slave
-
-  GodotMethodAttributes* = object
-    rpcMode*: GodotMethodRPCMode
-
-  GodotPropertyHint* {.size: sizeof(cint), pure.} = enum
-    None, ## no hint provided.
-    Range, ## hint_text = "min,max,step,slider; // slider is optional"
-    ExpRange, ## hint_text = "min,max,step", exponential edit
-    Enum, ## hint_text= "val1,val2,val3,etc"
-    ExpEasing, ## exponential easing funciton (Math::ease)
-    Length, ## hint_text= "length" (as integer)
-    SpriteFrame,
-    KeyAccel, ## hint_text= "length" (as integer)
-    Flags, ##  hint_text= "flag1,flag2,etc" (as bit flags)
-    Layers2DRender,
-    Layers2DPhysics,
-    Layers3DRender,
-    Layers3DPhysics,
-    File, ## a file path must be passed, hint_text (optionally)
-          ## is a filter "*.png,*.wav,*.doc,"
-    Dir,  ## a directort path must be passed
-    GlobalFile, ## a file path must be passed, hint_text (optionally) is a
-                ## filter "*.png,*.wav,*.doc,"
-    GlobalDir, ## a directort path must be passed
-    ResourceType, ## a resource object type
-    MultilineText, ## used for string properties that can contain multiple lines
-    ColorNoAlpha, ## used for ignoring alpha component when editing a color
-    ImageCompressLossy,
-    ImageCompressLossless,
-    ObjectId,
-    TypeString, ## a type string, the hint is the base type to choose
-    NodePathToEditedNode, ## so something else can provide this
-                          ## (used in scripts)
-    MethodOfVariantType, ## a method of a type
-    MethodOfBaseType, ## a method of a base type
-    MethodOfInstance, ## a method of an instance
-    MethodOfScript, ## a method of a script & base
-    PropertyOfVariantType, ## a property of a type
-    PropertyOfBaseType, ## a property of a base type
-    PropertyOfInstance, ## a property of an instance
-    PropertyOfScript, ## a property of a script & base
-    PropertyHintMax
-
-const
-  GODOT_PROPERTY_USAGE_STORAGE_VALUE = 1.cint
-  GODOT_PROPERTY_USAGE_EDITOR_VALUE = 2.cint
-  GODOT_PROPERTY_USAGE_NETWORK_VALUE = 4.cint
-  GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE = 8.cint
-  GODOT_PROPERTY_USAGE_CHECKABLE_VALUE = 16.cint
-  GODOT_PROPERTY_USAGE_CHECKED_VALUE = 32.cint
-  GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE = 64.cint
-  GODOT_PROPERTY_USAGE_GROUP_VALUE = 128.cint
-  GODOT_PROPERTY_USAGE_CATEGORY_VALUE = 256.cint
-  GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE = 512.cint
-  GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE = 1024.cint
-  GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE = 2048.cint
-  GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE = 4096.cint
-  GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE = 8192.cint
-  GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE = 16384.cint
-  GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE = 32768.cint
-  GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE = 65536.cint
-
-  GODOT_PROPERTY_USAGE_DEFAULT_VALUE: cint =
-      GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_EDITOR_VALUE or
-      GODOT_PROPERTY_USAGE_NETWORK_VALUE
-  GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE: cint =
-      GODOT_PROPERTY_USAGE_STORAGE_VALUE or
-      GODOT_PROPERTY_USAGE_EDITOR_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE or
-      GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
-  GODOT_PROPERTY_USAGE_NOEDITOR_VALUE: cint =
-      GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE
-
-type
-  GodotPropertyUsage* {.size: sizeof(cint), pure.} = enum
-    Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE
-    Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE
-    Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE
-    NoEditor = GODOT_PROPERTY_USAGE_NOEDITOR_VALUE
-    Default = GODOT_PROPERTY_USAGE_DEFAULT_VALUE
-    EditorHelper = GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE
-    Checkable = GODOT_PROPERTY_USAGE_CHECKABLE_VALUE
-      ## used for editing global variables
-    Checked = GODOT_PROPERTY_USAGE_CHECKED_VALUE
-      ## used for editing global variables
-    Internationalized = GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
-      ## hint for internationalized strings
-    DefaultIntl = GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE
-    Group = GODOT_PROPERTY_USAGE_GROUP_VALUE
-      ## used for grouping props in the editor
-    Category = GODOT_PROPERTY_USAGE_CATEGORY_VALUE
-    NonZero = GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE
-      ## only store if nonzero
-    NonOne = GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE
-      ## only store if false
-    NoInstanceState = GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE
-    RestartIfChanged = GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE
-    ScriptVariable = GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE
-    StoreIfNull = GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE
-    AnimateAsTrigger = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE
-    UpdateAllIfModified = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE
-
-  GodotPropertyAttributes* {.bycopy.} = object
-    rsetType*: GodotMethodRPCMode
-    typ*: cint
-    hint*: GodotPropertyHint
-    hintString*: GodotString
-    usage*: cint
-    defaultValue*: GodotVariant
-
-  GodotInstanceCreateFunc* {.bycopy.} = object
-    createFunc*:
-      proc (obj: ptr GodotObject; methodData: pointer): pointer {.noconv.}
-        ## returns user data
-    methodData*: pointer
-    freeFunc*: proc (a2: pointer) {.noconv.}
-
-  GodotInstanceDestroyFunc* {.bycopy.} = object
-    destroyFunc*:
-      proc (obj: ptr GodotObject; methodData: pointer;
-            userData: pointer) {.noconv.}
-    methodData*: pointer
-    freeFunc*: proc (a2: pointer) {.noconv.}
-
-  GodotInstanceMethod* {.bycopy.} = object
-    meth*:
-      proc (obj: ptr GodotObject; methodData: pointer;
-            userData: pointer; numArgs: cint;
-            args: var array[MAX_ARG_COUNT, ptr GodotVariant]):
-              GodotVariant {.noconv.}
-    methodData*: pointer
-    freeFunc*: proc (a2: pointer) {.noconv.}
-
-  GodotPropertySetFunc* {.bycopy.} = object
-    setFunc*: proc (obj: ptr GodotObject; methodData: pointer;
-                    userData: pointer; value: GodotVariant) {.noconv.}
-    methodData*: pointer
-    freeFunc*: proc (a2: pointer) {.noconv.}
-
-  GodotPropertyGetFunc* {.bycopy.} = object
-    getFunc*: proc (obj: ptr GodotObject; methodData: pointer;
-                    userData: pointer): GodotVariant {.noconv.}
-    methodData*: pointer
-    freeFunc*: proc (a2: pointer) {.noconv.}
-
-  GodotSignalArgument* {.bycopy.} = object
-    name*: GodotString
-    typ*: cint
-    hint*: GodotPropertyHint
-    hintString*: GodotString
-    usage*: cint
-    defaultValue*: GodotVariant
-
-  GodotSignal* = object
-    name*: GodotString
-    numArgs*: cint
-    args*: ptr GodotSignalArgument
-    numDefaultArgs*: cint
-    defaultArgs*: ptr GodotVariant
-
-  GodotClassConstructor* = proc (): ptr GodotObject {.
-    noconv, gcsafe, locks: 0, raises: [], tags: [].}
-
-template offset*[T](p: ptr T, offset: int): ptr T =
-  cast[ptr T](cast[ByteAddress](p) +% (offset * sizeof(T)))

godot/internal/godotnodepaths.nim

@@ -1,40 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import godotinternaltypes, gdnativeapi
-
-proc initGodotNodePath*(dest: var GodotNodePath; s: GodotString) {.inline.} =
-  getGDNativeAPI().nodePathNew(dest, s)
-
-proc initGodotNodePath*(dest: var GodotNodePath;
-                        src: GodotNodePath) {.inline.} =
-  getGDNativeAPI().nodePathNewCopy(dest, src)
-
-proc deinit*(self: var GodotNodePath) {.inline.} =
-  getGDNativeAPI().nodePathDestroy(self)
-
-proc toGodotString*(self: GodotNodePath): GodotString {.inline.} =
-  getGDNativeAPI().nodePathAsString(self)
-
-proc isAbsolute*(self: GodotNodePath): bool {.inline.} =
-  getGDNativeAPI().nodePathIsAbsolute(self)
-
-proc nameCount*(self: GodotNodePath): cint {.inline.} =
-  getGDNativeAPI().nodePathGetNameCount(self)
-
-proc getName*(self: GodotNodePath; idx: cint): GodotString {.inline.} =
-  getGDNativeAPI().nodePathGetName(self, idx)
-
-proc subnameCount*(self: GodotNodePath): cint {.inline.} =
-  getGDNativeAPI().nodePathGetSubnameCount(self)
-
-proc getSubname*(self: GodotNodePath; idx: cint): GodotString {.inline.} =
-  getGDNativeAPI().nodePathGetSubname(self, idx)
-
-proc getConcatenatedSubnames*(self: GodotNodePath): GodotString {.inline.} =
-  getGDNativeAPI().nodePathGetConcatenatedSubnames(self)
-
-proc isEmpty*(self: GodotNodePath): bool {.inline.} =
-  getGDNativeAPI().nodePathIsEmpty(self)
-
-proc `==`*(a, b: GodotNodePath): bool {.inline.} =
-  getGDNativeAPI().nodePathOperatorEqual(a, b)

godot/internal/godotpoolarrays.nim

@@ -1,269 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import godotinternaltypes, gdnativeapi
-import core/godotcoretypes
-
-template genPoolArrayAPI(ArrayT, initIdent, DataT,
-                         newProc, newCopyProc, newWithArrayProc, appendProc,
-                         appendArrayProc, insertProc, invertProc, pushBackProc,
-                         removeProc, resizeProc, setProc, getProc, sizeProc,
-                         destroyProc, readProc, writeProc,
-                         readAccessPtrProc, writeAccessPtrProc,
-                         readAccessDestroyProc, writeAccessDestroyProc) =
-  proc initIdent*(dest: var ArrayT) {.inline.} =
-    getGDNativeAPI().newProc(dest)
-
-  proc initIdent*(dest: var ArrayT; src: ArrayT) {.inline.} =
-    getGDNativeAPI().newCopyProc(dest, src)
-
-  proc initIdent*(dest: var ArrayT; arr: GodotArray) {.inline.} =
-    getGDNativeAPI().newWithArrayProc(dest, arr)
-
-  proc deinit*(self: var ArrayT) {.inline.} =
-    getGDNativeAPI().destroyProc(self)
-
-  proc add*(self: var ArrayT; data: DataT) {.inline.} =
-    getGDNativeAPI().pushBackProc(self, data)
-
-  proc add*(self: var ArrayT; arr: ArrayT) {.inline.} =
-    getGDNativeAPI().appendArrayProc(self, arr)
-
-  proc insert*(self: var ArrayT; idx: cint;
-               data: DataT): Error {.inline.} =
-    getGDNativeAPI().insertProc(self, idx, data)
-
-  proc delete*(self: var ArrayT; idx: cint) {.inline.} =
-    getGDNativeAPI().removeProc(self, idx)
-
-  proc reverse*(self: var ArrayT) {.inline.} =
-    getGDNativeAPI().invertProc(self)
-
-  proc setLen*(self: var ArrayT; size: cint) {.inline.} =
-    getGDNativeAPI().resizeProc(self, size)
-
-  proc `[]=`*(self: var ArrayT; idx: cint; data: DataT) {.inline.} =
-    getGDNativeAPI().setProc(self, idx, data)
-
-  proc `[]`*(self: ArrayT; idx: cint): DataT {.inline.} =
-    let data = getGDNativeAPI().getProc(self, idx)
-    when DataT is Color:
-      data.toColor()
-    elif DataT is Vector2:
-      data.toVector2()
-    elif DataT is Vector3:
-      data.toVector3()
-    else:
-      data
-
-  proc len*(self: ArrayT): cint {.inline.} =
-    getGDNativeAPI().sizeProc(self)
-
-  iterator items*(self: ArrayT): DataT =
-    let readAccess = getGDNativeAPI().readProc(self)
-    let readPtr = getGDNativeAPI().readAccessPtrProc(readAccess)
-    for i in 0.cint..<self.len:
-      yield readPtr.offset(i)[]
-    getGDNativeAPI().readAccessDestroyProc(readAccess)
-
-  iterator mitems*(self: var ArrayT): var DataT =
-    let writeAccess = getGDNativeAPI().writeProc(self)
-    let writePtr = getGDNativeAPI().writeAccessPtrProc(writeAccess)
-    for i in 0.cint..<self.len:
-      yield writePtr.offset(i)[]
-    getGDNativeAPI().writeAccessDestroyProc(writeAccess)
-
-  iterator pairs*(self: ArrayT): tuple[key: cint, val: DataT] =
-    let readAccess = getGDNativeAPI().readProc(self)
-    let readPtr = getGDNativeAPI().readAccessPtrProc(readAccess)
-    for i in 0.cint..<self.len:
-      yield (i, readPtr.offset(i)[])
-    getGDNativeAPI().readAccessDestroyProc(readAccess)
-
-  iterator mpairs*(self: var ArrayT): tuple[key: cint, val: var DataT] =
-    let writeAccess = getGDNativeAPI().writeProc(self)
-    let writePtr = getGDNativeAPI().writeAccessPtrProc(writeAccess)
-    for i in 0.cint..<self.len:
-      yield (i, writePtr.offset(i)[])
-    getGDNativeAPI().writeAccessDestroyProc(writeAccess)
-
-  proc subarray*(self: ArrayT, idxFrom, idxTo: cint): ArrayT =
-    ## Indexes are inclusive, negative values count from the end of the array.
-    let ownLen = self.len
-    var actualIdxFrom = if idxFrom < 0: idxFrom + ownLen
-                        else: idxFrom
-    var actualIdxTo = if idxTo < 0: idxTo + ownLen
-                      else: idxTo
-
-    initIdent(result)
-    if actualIdxFrom < 0 or actualIdxFrom >= 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,
-                poolByteArrayNewCopy,
-                poolByteArrayNewWithArray,
-                poolByteArrayAppend,
-                poolByteArrayAppendArray,
-                poolByteArrayInsert,
-                poolByteArrayInvert,
-                poolByteArrayPushBack,
-                poolByteArrayRemove,
-                poolByteArrayResize,
-                poolByteArraySet,
-                poolByteArrayGet,
-                poolByteArraySize,
-                poolByteArrayDestroy,
-                poolByteArrayRead,
-                poolByteArrayWrite,
-                poolByteArrayReadAccessPtr,
-                poolByteArrayWriteAccessPtr,
-                poolByteArrayReadAccessDestroy,
-                poolByteArrayWriteAccessDestroy)
-
-genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint,
-                poolIntArrayNew,
-                poolIntArrayNewCopy,
-                poolIntArrayNewWithArray,
-                poolIntArrayAppend,
-                poolIntArrayAppendArray,
-                poolIntArrayInsert,
-                poolIntArrayInvert,
-                poolIntArrayPushBack,
-                poolIntArrayRemove,
-                poolIntArrayResize,
-                poolIntArraySet,
-                poolIntArrayGet,
-                poolIntArraySize,
-                poolIntArrayDestroy,
-                poolIntArrayRead,
-                poolIntArrayWrite,
-                poolIntArrayReadAccessPtr,
-                poolIntArrayWriteAccessPtr,
-                poolIntArrayReadAccessDestroy,
-                poolIntArrayWriteAccessDestroy)
-
-genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32,
-                poolRealArrayNew,
-                poolRealArrayNewCopy,
-                poolRealArrayNewWithArray,
-                poolRealArrayAppend,
-                poolRealArrayAppendArray,
-                poolRealArrayInsert,
-                poolRealArrayInvert,
-                poolRealArrayPushBack,
-                poolRealArrayRemove,
-                poolRealArrayResize,
-                poolRealArraySet,
-                poolRealArrayGet,
-                poolRealArraySize,
-                poolRealArrayDestroy,
-                poolRealArrayRead,
-                poolRealArrayWrite,
-                poolRealArrayReadAccessPtr,
-                poolRealArrayWriteAccessPtr,
-                poolRealArrayReadAccessDestroy,
-                poolRealArrayWriteAccessDestroy)
-
-genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString,
-                poolStringArrayNew,
-                poolStringArrayNewCopy,
-                poolStringArrayNewWithArray,
-                poolStringArrayAppend,
-                poolStringArrayAppendArray,
-                poolStringArrayInsert,
-                poolStringArrayInvert,
-                poolStringArrayPushBack,
-                poolStringArrayRemove,
-                poolStringArrayResize,
-                poolStringArraySet,
-                poolStringArrayGet,
-                poolStringArraySize,
-                poolStringArrayDestroy,
-                poolStringArrayRead,
-                poolStringArrayWrite,
-                poolStringArrayReadAccessPtr,
-                poolStringArrayWriteAccessPtr,
-                poolStringArrayReadAccessDestroy,
-                poolStringArrayWriteAccessDestroy)
-
-genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2,
-                poolVector2ArrayNew,
-                poolVector2ArrayNewCopy,
-                poolVector2ArrayNewWithArray,
-                poolVector2ArrayAppend,
-                poolVector2ArrayAppendArray,
-                poolVector2ArrayInsert,
-                poolVector2ArrayInvert,
-                poolVector2ArrayPushBack,
-                poolVector2ArrayRemove,
-                poolVector2ArrayResize,
-                poolVector2ArraySet,
-                poolVector2ArrayGet,
-                poolVector2ArraySize,
-                poolVector2ArrayDestroy,
-                poolVector2ArrayRead,
-                poolVector2ArrayWrite,
-                poolVector2ArrayReadAccessPtr,
-                poolVector2ArrayWriteAccessPtr,
-                poolVector2ArrayReadAccessDestroy,
-                poolVector2ArrayWriteAccessDestroy)
-
-genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3,
-                poolVector3ArrayNew,
-                poolVector3ArrayNewCopy,
-                poolVector3ArrayNewWithArray,
-                poolVector3ArrayAppend,
-                poolVector3ArrayAppendArray,
-                poolVector3ArrayInsert,
-                poolVector3ArrayInvert,
-                poolVector3ArrayPushBack,
-                poolVector3ArrayRemove,
-                poolVector3ArrayResize,
-                poolVector3ArraySet,
-                poolVector3ArrayGet,
-                poolVector3ArraySize,
-                poolVector3ArrayDestroy,
-                poolVector3ArrayRead,
-                poolVector3ArrayWrite,
-                poolVector3ArrayReadAccessPtr,
-                poolVector3ArrayWriteAccessPtr,
-                poolVector3ArrayReadAccessDestroy,
-                poolVector3ArrayWriteAccessDestroy)
-
-genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color,
-                poolColorArrayNew,
-                poolColorArrayNewCopy,
-                poolColorArrayNewWithArray,
-                poolColorArrayAppend,
-                poolColorArrayAppendArray,
-                poolColorArrayInsert,
-                poolColorArrayInvert,
-                poolColorArrayPushBack,
-                poolColorArrayRemove,
-                poolColorArrayResize,
-                poolColorArraySet,
-                poolColorArrayGet,
-                poolColorArraySize,
-                poolColorArrayDestroy,
-                poolColorArrayRead,
-                poolColorArrayWrite,
-                poolColorArrayReadAccessPtr,
-                poolColorArrayWriteAccessPtr,
-                poolColorArrayReadAccessDestroy,
-                poolColorArrayWriteAccessDestroy)

godot/internal/godotstrings.nim

@@ -1,54 +0,0 @@
-# Copyright (c) 2018 Xored Software, Inc.
-
-import godotinternaltypes, gdnativeapi
-
-proc initGodotString(dest: var GodotString) {.inline, raises: [].} =
-  getGDNativeAPI().stringNew(dest)
-
-proc initGodotString(dest: var GodotString; contents: cstring;
-                     size: cint) {.inline.} =
-  ## Initializes ``dest`` from UTF-8 ``contents``
-  dest = getGDNativeAPI().stringCharsToUtf8WithLen(contents, size)
-
-proc `==`*(self, b: GodotString): bool {.inline.} =
-  getGDNativeAPI().stringOperatorEqual(self, b)
-
-proc `<`*(self, b: GodotString): bool {.inline.} =
-  getGDNativeAPI().stringOperatorLess(self, b)
-
-proc `&`*(self, b: GodotString): GodotString {.inline.} =
-  getGDNativeAPI().stringOperatorPlus(self, b)
-
-proc deinit*(self: var GodotString) {.inline.} =
-  getGDNativeAPI().stringDestroy(self)
-
-proc len*(self: GodotString): cint {.inline.} =
-  getGDNativeAPI().stringLength(self)
-
-proc dataPtr*(self: GodotString): ptr cwchar_t {.inline.} =
-  getGDNativeAPI().stringWideStr(self)
-
-proc `$`*(self: GodotString): string =
-  ## Converts the ``GodotString`` into Nim string
-  var charStr = getGDNativeAPI().stringUtf8(self)
-  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``
-  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
-    if s.isNil:
-      initGodotString(result)
-    else:
-      initGodotString(result, cstring(s), cint(s.len + 1))
-  else:
-    initGodotString(result, cstring(s), cint(s.len + 1))
-
-proc toGodotString*(s: cstring): GodotString {.inline.} =
-  ## Converts the cstring into ``GodotString``
-  if s.isNil:
-    initGodotString(result)
-  else:
-    initGodotString(result, s, cint(s.len + 1))

godot/internal/godotvariants.nim

@@ -1,217 +0,0 @@
-# Copyright 2018 Xored Software, Inc.
-
-import core/godotcoretypes, godotinternaltypes, gdnativeapi
-
-proc getType*(p: GodotVariant): VariantType {.inline.} =
-  getGDNativeAPI().variantGetType(p)
-
-proc initGodotVariant*(dest: var GodotVariant) {.inline.} =
-  getGDNativeAPI().variantNewNil(dest)
-
-proc initGodotVariant*(dest: var GodotVariant, src: GodotVariant) {.inline.} =
-  getGDNativeAPI().variantNewCopy(dest, src)
-
-proc initGodotVariant*(dest: var GodotVariant; b: bool) {.inline.} =
-  getGDNativeAPI().variantNewBool(dest, b)
-
-proc initGodotVariant*(dest: var GodotVariant; i: uint64) {.inline.} =
-  getGDNativeAPI().variantNewUInt(dest, i)
-
-proc initGodotVariant*(dest: var GodotVariant; i: int64) {.inline.} =
-  getGDNativeAPI().variantNewInt(dest, i)
-
-proc initGodotVariant*(dest: var GodotVariant; r: cdouble) {.inline.} =
-  getGDNativeAPI().variantNewReal(dest, r)
-
-proc initGodotVariant*(dest: var GodotVariant; s: GodotString) {.inline.} =
-  getGDNativeAPI().variantNewString(dest, s)
-
-proc initGodotVariant*(dest: var GodotVariant; v2: Vector2) {.inline.} =
-  getGDNativeAPI().variantNewVector2(dest, v2)
-
-proc initGodotVariant*(dest: var GodotVariant; rect2: Rect2) {.inline.} =
-  getGDNativeAPI().variantNewRect2(dest, rect2)
-
-proc initGodotVariant*(dest: var GodotVariant; v3: Vector3) {.inline.} =
-  getGDNativeAPI().variantNewVector3(dest, v3)
-
-proc initGodotVariant*(dest: var GodotVariant; t2d: Transform2D) {.inline.} =
-  getGDNativeAPI().variantNewTransform2D(dest, t2d)
-
-proc initGodotVariant*(dest: var GodotVariant; plane: Plane) {.inline.} =
-  getGDNativeAPI().variantNewPlane(dest, plane)
-
-proc initGodotVariant*(dest: var GodotVariant; quat: Quat) {.inline.} =
-  getGDNativeAPI().variantNewQuat(dest, quat)
-
-proc initGodotVariant*(dest: var GodotVariant; aabb: AABB) {.inline.} =
-  getGDNativeAPI().variantNewAABB(dest, aabb)
-
-proc initGodotVariant*(dest: var GodotVariant; basis: Basis) {.inline.} =
-  getGDNativeAPI().variantNewBasis(dest, basis)
-
-proc initGodotVariant*(dest: var GodotVariant; trans: Transform) {.inline.} =
-  getGDNativeAPI().variantNewTransform(dest, trans)
-
-proc initGodotVariant*(dest: var GodotVariant; color: Color) {.inline.} =
-  getGDNativeAPI().variantNewColor(dest, color)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       nodePath: GodotNodePath) {.inline.} =
-  getGDNativeAPI().variantNewNodePath(dest, nodePath)
-
-proc initGodotVariant*(dest: var GodotVariant; rid: RID) {.inline.} =
-  getGDNativeAPI().variantNewRID(dest, rid)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       obj: ptr GodotObject) {.inline.} =
-  getGDNativeAPI().variantNewObject(dest, obj)
-
-proc initGodotVariant*(dest: var GodotVariant; arr: GodotArray) {.inline.} =
-  getGDNativeAPI().variantNewArray(dest, arr)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       pba: GodotPoolByteArray) {.inline.} =
-  getGDNativeAPI().variantNewPoolByteArray(dest, pba)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       pia: GodotPoolIntArray) {.inline.} =
-  getGDNativeAPI().variantNewPoolIntArray(dest, pia)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       pra: GodotPoolRealArray) {.inline.} =
-  getGDNativeAPI().variantNewPoolRealArray(dest, pra)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       psa: GodotPoolStringArray) {.inline.} =
-  getGDNativeAPI().variantNewPoolStringArray(dest, psa)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       pv2a: GodotPoolVector2Array) {.inline.} =
-  getGDNativeAPI().variantNewPoolVector2Array(dest, pv2a)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       pv3a: GodotPoolVector3Array) {.inline.} =
-  getGDNativeAPI().variantNewPoolVector3Array(dest, pv3a)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       pca: GodotPoolColorArray) {.inline.} =
-  getGDNativeAPI().variantNewPoolColorArray(dest, pca)
-
-proc initGodotVariant*(dest: var GodotVariant;
-                       dict: GodotDictionary) {.inline.} =
-  getGDNativeAPI().variantNewDictionary(dest, dict)
-
-proc deinit*(v: var GodotVariant) {.inline.} =
-  getGDNativeAPI().variantDestroy(v)
-
-proc asBool*(self: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().variantAsBool(self)
-
-proc asUInt*(self: GodotVariant): uint64 {.inline.} =
-  getGDNativeAPI().variantAsUInt(self)
-
-proc asInt*(self: GodotVariant): int64 {.inline.} =
-  getGDNativeAPI().variantAsInt(self)
-
-proc asReal*(self: GodotVariant): cdouble {.inline.} =
-  getGDNativeAPI().variantAsReal(self)
-
-proc asGodotString*(self: GodotVariant): GodotString {.inline.} =
-  getGDNativeAPI().variantAsString(self)
-
-proc asVector2*(self: GodotVariant): Vector2 {.inline.} =
-  getGDNativeAPI().variantAsVector2(self).toVector2()
-
-proc asRect2*(self: GodotVariant): Rect2 {.inline.} =
-  getGDNativeAPI().variantAsRect2(self).toRect2()
-
-proc asVector3*(self: GodotVariant): Vector3 {.inline.} =
-  getGDNativeAPI().variantAsVector3(self).toVector3()
-
-proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} =
-  getGDNativeAPI().variantAsTransform2D(self).toTransform2D()
-
-proc asPlane*(self: GodotVariant): Plane {.inline.} =
-  getGDNativeAPI().variantAsPlane(self).toPlane()
-
-proc asQuat*(self: GodotVariant): Quat {.inline.} =
-  getGDNativeAPI().variantAsQuat(self).toQuat()
-
-proc asAABB*(self: GodotVariant): AABB {.inline.} =
-  getGDNativeAPI().variantAsAABB(self).toAABB()
-
-proc asBasis*(self: GodotVariant): Basis {.inline.} =
-  getGDNativeAPI().variantAsBasis(self).toBasis()
-
-proc asTransform*(self: GodotVariant): Transform {.inline.} =
-  getGDNativeAPI().variantAsTransform(self).toTransform()
-
-proc asColor*(self: GodotVariant): Color {.inline.} =
-  getGDNativeAPI().variantAsColor(self).toColor()
-
-proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} =
-  getGDNativeAPI().variantAsNodePath(self)
-
-proc asRID*(self: GodotVariant): RID {.inline.} =
-  getGDNativeAPI().variantAsRID(self)
-
-proc asGodotObject*(self: GodotVariant): ptr GodotObject {.inline.} =
-  getGDNativeAPI().variantAsObject(self)
-
-proc asGodotArray*(self: GodotVariant): GodotArray {.inline.} =
-  getGDNativeAPI().variantAsArray(self)
-
-proc asGodotPoolByteArray*(self: GodotVariant): GodotPoolByteArray {.inline.} =
-  getGDNativeAPI().variantAsPoolByteArray(self)
-
-proc asGodotPoolIntArray*(self: GodotVariant): GodotPoolIntArray {.inline.} =
-  getGDNativeAPI().variantAsPoolIntArray(self)
-
-proc asGodotPoolRealArray*(self: GodotVariant): GodotPoolRealArray {.inline.} =
-  getGDNativeAPI().variantAsPoolRealArray(self)
-
-proc asGodotPoolStringArray*(self: GodotVariant): GodotPoolStringArray
-                            {.inline.} =
-  getGDNativeAPI().variantAsPoolStringArray(self)
-
-proc asGodotPoolVector2Array*(self: GodotVariant): GodotPoolVector2Array
-                             {.inline.} =
-  getGDNativeAPI().variantAsPoolVector2Array(self)
-
-proc asGodotPoolVector3Array*(self: GodotVariant): GodotPoolVector3Array
-                             {.inline.} =
-  getGDNativeAPI().variantAsPoolVector3Array(self)
-
-proc asGodotPoolColorArray*(self: GodotVariant): GodotPoolColorArray
-                           {.inline.} =
-  getGDNativeAPI().variantAsPoolColorArray(self)
-
-proc asGodotDictionary*(self: GodotVariant): GodotDictionary {.inline.} =
-  getGDNativeAPI().variantAsDictionary(self)
-
-proc call*(self: var GodotVariant; meth: GodotString;
-           args: ptr array[256, ptr GodotVariant]; argCount: cint;
-           error: var VariantCallError): GodotVariant {.inline.} =
-  getGDNativeAPI().variantCall(self, meth, args, argCount, error)
-
-proc hasMethod*(self: GodotVariant; meth: GodotString): bool {.inline.} =
-  getGDNativeAPI().variantHasMethod(self, meth)
-
-proc `==`*(self, other: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().variantOperatorEqual(self, other)
-
-proc `<`*(self, other: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().variantOperatorLess(self, other)
-
-proc hashCompare*(self, other: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().variantHashCompare(self, other)
-
-proc booleanize*(self: GodotVariant): bool {.inline.} =
-  getGDNativeAPI().variantBooleanize(self)
-
-import godotstrings
-proc `$`*(self: GodotVariant): string =
-  var s = self.asGodotString()
-  result = $s
-  s.deinit()

godot/internal/nim.cfg

@@ -1 +0,0 @@
---path:"$projectdir/../"