Bump version to 0.8.2

Move template below arrays import
Fixes #81 Alternate workaround for https://github.com/nim-lang/Nim/issues/16462 without changing VariantType.
2021-05-03 23:18:50 +07:00 · 2021-05-03 23:17:18 +07:00 · 2021-03-12 11:09:55 +07:00 · 2020-12-13 12:13:41 +07:00 · 2020-10-17 13:22:31 +07:00 · 2020-08-14 01:44:48 +07:00
32 changed files with 990 additions and 669 deletions
--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
-# Nim bindings for Godot Engine [![Build Status](https://travis-ci.org/pragmagic/godot-nim.svg?branch=master)](https://travis-ci.org/pragmagic/godot-nim)
+# Nim bindings for Godot Engine

-Nim bindings for Godot 3.0 based on [GDNative](https://godotengine.org/article/dlscript-here).
+Nim bindings for Godot 3 based on [GDNative](https://godotengine.org/article/dlscript-here).

 Documentation: https://pragmagic.github.io/godot-nim/

--- a/docs/docbuild.nim
+++ b/docs/docbuild.nim
@ -71,7 +71,7 @@ proc fixupHrefs(file: string) =

 proc getGitHash(): string =
  result = execProcess("git rev-parse HEAD")
-  if not result.isNil and result.len > 0:
+  if result.len > 0:
    result = result.replace("\L", "").replace("\r", "")

 proc buildDocs*(outDir, godotNimDir, godotBin: string) =
@ -112,7 +112,7 @@ proc buildDocs*(outDir, godotNimDir, godotBin: string) =
  var gitHash: string
  withDir(godotBinAbs.parentDir()):
    gitHash = getGitHash()
-    if gitHash.isNil or gitHash.len == 0:
+    if gitHash.len == 0:
      raise newException(Exception,
        "Godot executable is not under Git repository")

--- a/godot.nimble
+++ b/godot.nimble
@ -1,4 +1,4 @@
-version = "0.7.14"
+version = "0.8.2"
 author = "Xored Software, Inc."
 description = "Godot Engine bindings"
 license = "MIT"
--- a/godot/core/aabb.nim
+++ b/godot/core/aabb.nim
@ -3,7 +3,7 @@
 import hashes

 import vector3
-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi

 proc initAABB*(pos, size: Vector3): AABB {.inline.} =
@ -31,10 +31,10 @@ proc encloses*(self, other: AABB): bool {.inline.} =
  getGDNativeAPI().aabbEncloses(self, other)

 proc merge*(self, other: AABB): AABB {.inline.} =
-  getGDNativeAPI().aabbMerge(self, other)
+  getGDNativeAPI().aabbMerge(self, other).toAABB()

 proc intersection*(self, other: AABB): AABB {.inline.} =
-  getGDNativeAPI().aabbIntersection(self, other)
+  getGDNativeAPI().aabbIntersection(self, other).toAABB()

 proc intersectsPlane*(self: AABB; plane: Plane): bool {.inline.} =
  getGDNativeAPI().aabbIntersectsPlane(self, plane)
@ -46,10 +46,10 @@ proc contains*(self: AABB; point: Vector3): bool {.inline.} =
  getGDNativeAPI().aabbHasPoint(self, point)

 proc getSupport*(self: AABB; dir: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().aabbGetSupport(self, dir)
+  getGDNativeAPI().aabbGetSupport(self, dir).toVector3()

 proc getLongestAxis*(self: AABB): Vector3 {.inline.} =
-  getGDNativeAPI().aabbGetLongestAxis(self)
+  getGDNativeAPI().aabbGetLongestAxis(self).toVector3()

 proc getLongestAxisIndex*(self: AABB): cint {.inline.} =
  getGDNativeAPI().aabbGetLongestAxisIndex(self)
@ -58,7 +58,7 @@ proc getLongestAxisSize*(self: AABB): float32 {.inline.} =
  getGDNativeAPI().aabbGetLongestAxisSize(self)

 proc getShortestAxis*(self: AABB): Vector3 {.inline.} =
-  getGDNativeAPI().aabbGetShortestAxis(self)
+  getGDNativeAPI().aabbGetShortestAxis(self).toVector3()

 proc getShortestAxisIndex*(self: AABB): cint {.inline.} =
  getGDNativeAPI().aabbGetShortestAxisIndex(self)
@ -67,13 +67,13 @@ proc getShortestAxisSize*(self: AABB): float32 {.inline.} =
  getGDNativeAPI().aabbGetShortestAxisSize(self)

 proc expand*(self: AABB; toPoint: Vector3): AABB {.inline.} =
-  getGDNativeAPI().aabbExpand(self, toPoint)
+  getGDNativeAPI().aabbExpand(self, toPoint).toAABB()

 proc grow*(self: AABB; by: float32): AABB {.inline.} =
-  getGDNativeAPI().aabbGrow(self, by)
+  getGDNativeAPI().aabbGrow(self, by).toAABB()

 proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} =
-  getGDNativeAPI().aabbGetEndpoint(self, idx)
+  getGDNativeAPI().aabbGetEndpoint(self, idx).toVector3()

 proc `==`*(a, b: AABB): bool {.inline.} =
  getGDNativeAPI().aabbOperatorEqual(a, b)
--- a/godot/core/arrays.nim
+++ b/godot/core/arrays.nim
@ -1,7 +1,7 @@
 # Copyright 2018 Xored Software, Inc.

 import hashes
-import internal.godotinternaltypes, internal.godotarrays
+import internal/godotinternaltypes, internal/godotarrays

 type
  Array* = ref object
--- a/godot/core/colors.nim
+++ b/godot/core/colors.nim
@ -64,16 +64,16 @@ proc gray*(self: Color): float32 {.inline.} =
  getGDNativeAPI().colorGray(self)

 proc inverted*(self: Color): Color {.inline.} =
-  getGDNativeAPI().colorInverted(self)
+  getGDNativeAPI().colorInverted(self).toColor()

 proc contrasted*(self: Color): Color {.inline.} =
-  getGDNativeAPI().colorContrasted(self)
+  getGDNativeAPI().colorContrasted(self).toColor()

 proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} =
-  getGDNativeAPI().colorLinearInterpolate(self, b, t)
+  getGDNativeAPI().colorLinearInterpolate(self, b, t).toColor()

 proc blend*(self: Color; over: Color): Color {.inline.} =
-  getGDNativeAPI().colorBlend(self, over)
+  getGDNativeAPI().colorBlend(self, over).toColor()

 proc `==`*(a, b: Color): bool {.inline.} =
  a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a
--- a/godot/core/dictionaries.nim
+++ b/godot/core/dictionaries.nim
@ -1,8 +1,8 @@
 # Copyright 2018 Xored Software, Inc.

 import hashes
-import internal.godotinternaltypes, internal.godotdictionaries,
-       internal.godotvariants, internal.godotstrings
+import internal/godotinternaltypes, internal/godotdictionaries,
+       internal/godotvariants, internal/godotstrings

 type
  Dictionary* = ref object
--- a/godot/core/godotbase.nim
+++ b/godot/core/godotbase.nim
@ -30,6 +30,9 @@ proc stepify*(value, step: float32): float32 {.inline, noinit.} =
  else:
    value

+when (NimMajor, NimMinor, NimPatch) < (0, 20, 4):
+  # Newer Nim has these procs in system module
+
  proc min*(x, y: float32): float32 {.inline, noinit.} =
    if x <= y: x else: y

--- a/godot/core/nodepaths.nim
+++ b/godot/core/nodepaths.nim
@ -2,8 +2,8 @@

 import hashes

-import internal.godotinternaltypes, internal.godotnodepaths,
-       internal.godotstrings
+import internal/godotinternaltypes, internal/godotnodepaths,
+       internal/godotstrings

 type
  NodePath* = ref object
--- a/godot/core/planes.nim
+++ b/godot/core/planes.nim
@ -4,7 +4,7 @@ import hashes

 import vector3

-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi

 proc initPlane*(a, b, c, d: float32): Plane {.inline.} =
@ -26,13 +26,13 @@ proc hash*(self: Plane): Hash {.inline, noinit.} =
  !$(self.normal.hash() !& self.d.hash())

 proc normalized*(self: Plane): Plane {.inline.} =
-  getGDNativeAPI().planeNormalized(self)
+  getGDNativeAPI().planeNormalized(self).toPlane()

 proc center*(self: Plane): Vector3 {.inline.} =
-  getGDNativeAPI().planeCenter(self)
+  getGDNativeAPI().planeCenter(self).toVector3()

 proc getAnyPoint*(self: Plane): Vector3 {.inline.} =
-  getGDNativeAPI().planeGetAnyPoint(self)
+  getGDNativeAPI().planeGetAnyPoint(self).toVector3()

 proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} =
  getGDNativeAPI().planeIsPointOver(self, point)
@ -45,7 +45,7 @@ proc contains*(self: Plane; point: Vector3;
  getGDNativeAPI().planeHasPoint(self, point, epsilon)

 proc project*(self: Plane; point: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().planeProject(self, point)
+  getGDNativeAPI().planeProject(self, point).toVector3()

 proc intersect3*(self: Plane; dest: var Vector3;
                 b, c: Plane): bool {.inline.} =
@ -60,7 +60,7 @@ proc intersectsSegment*(self: Plane; dest: var Vector3;
  getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd)

 proc `-`*(self: Plane): Plane {.inline.} =
-  getGDNativeAPI().planeOperatorNeg(self)
+  getGDNativeAPI().planeOperatorNeg(self).toPlane()

 proc `==`*(a, b: Plane): bool {.inline.} =
  getGDNativeAPI().planeOperatorEqual(a, b)
--- a/godot/core/poolarrays.nim
+++ b/godot/core/poolarrays.nim
@ -3,8 +3,8 @@
 import hashes

 import godotcoretypes
-import internal.godotinternaltypes, internal.godotpoolarrays,
-       internal.godotstrings
+import internal/godotinternaltypes, internal/godotpoolarrays,
+       internal/godotstrings
 import vector2, vector3, colors

 template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName,
@ -35,6 +35,30 @@ template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName,
        (when type(item) is GodotString: ($item).hash() else: item.hash())
    result = !$result

+definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8,
+                    godotPoolByteArray, newPoolByteArray,
+                    initGodotPoolByteArray)
+definePoolArrayBase(PoolIntArray, GodotPoolIntArray, cint,
+                    godotPoolIntArray, newPoolIntArray,
+                    initGodotPoolIntArray)
+definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float32,
+                    godotPoolRealArray, newPoolRealArray,
+                    initGodotPoolRealArray)
+definePoolArrayBase(PoolVector2Array, GodotPoolVector2Array, Vector2,
+                    godotPoolVector2Array, newPoolVector2Array,
+                    initGodotPoolVector2Array)
+definePoolArrayBase(PoolVector3Array, GodotPoolVector3Array, Vector3,
+                    godotPoolVector3Array, newPoolVector3Array,
+                    initGodotPoolVector3Array)
+definePoolArrayBase(PoolColorArray, GodotPoolColorArray, Color,
+                    godotPoolColorArray, newPoolColorArray,
+                    initGodotPoolColorArray)
+definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string,
+                    godotPoolStringArray, newPoolStringArray,
+                    initGodotPoolStringArray)
+
+import arrays
+
 template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
                         noData = false) =

@ -92,30 +116,6 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
      for pair in arr.fieldName.mpairs:
        yield (pair[0].int, pair[1])

-definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8,
-                    godotPoolByteArray, newPoolByteArray,
-                    initGodotPoolByteArray)
-definePoolArrayBase(PoolIntArray, GodotPoolIntArray, cint,
-                    godotPoolIntArray, newPoolIntArray,
-                    initGodotPoolIntArray)
-definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float32,
-                    godotPoolRealArray, newPoolRealArray,
-                    initGodotPoolRealArray)
-definePoolArrayBase(PoolVector2Array, GodotPoolVector2Array, Vector2,
-                    godotPoolVector2Array, newPoolVector2Array,
-                    initGodotPoolVector2Array)
-definePoolArrayBase(PoolVector3Array, GodotPoolVector3Array, Vector3,
-                    godotPoolVector3Array, newPoolVector3Array,
-                    initGodotPoolVector3Array)
-definePoolArrayBase(PoolColorArray, GodotPoolColorArray, Color,
-                    godotPoolColorArray, newPoolColorArray,
-                    initGodotPoolColorArray)
-definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string,
-                    godotPoolStringArray, newPoolStringArray,
-                    initGodotPoolStringArray)
-
-import arrays
-
 definePoolArray(PoolByteArray, GodotPoolByteArray, uint8,
                godotPoolByteArray, newPoolByteArray,
                initGodotPoolByteArray)
--- a/godot/core/quats.nim
+++ b/godot/core/quats.nim
@ -2,7 +2,7 @@

 import hashes

-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi

 proc initQuat*(x, y, z, w: float32): Quat {.inline.} =
@ -29,50 +29,50 @@ proc lengthSquared*(self: Quat): float32 {.inline.} =
  getGDNativeAPI().quatLengthSquared(self)

 proc normalized*(self: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatNormalized(self)
+  getGDNativeAPI().quatNormalized(self).toQuat()

 proc isNormalized*(self: Quat): bool {.inline.} =
  getGDNativeAPI().quatIsNormalized(self)

 proc inverse*(self: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatInverse(self)
+  getGDNativeAPI().quatInverse(self).toQuat()

 proc dot*(a, b: Quat): float32 {.inline.} =
  getGDNativeAPI().quatDot(a, b)

 proc xform*(self: Quat; v: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().quatXform(self, v)
+  getGDNativeAPI().quatXform(self, v).toVector3()

 proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
-  getGDNativeAPI().quatSlerp(self, b, t)
+  getGDNativeAPI().quatSlerp(self, b, t).toQuat()

 proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
-  getGDNativeAPI().quatSlerpni(self, b, t)
+  getGDNativeAPI().quatSlerpni(self, b, t).toQuat()

 proc cubicSlerp*(self, b, preA, postB: Quat;
                 t: float32): Quat {.inline.} =
-  getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t)
+  getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t).toQuat()

 proc `*`*(a: Quat, b: float32): Quat {.inline.} =
-  getGDNativeAPI().quatOperatorMultiply(a, b)
+  getGDNativeAPI().quatOperatorMultiply(a, b).toQuat()

 proc `*=`*(a: var Quat, b: float32) {.inline.} =
  a = a * b

 proc `+`*(a, b: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatOperatorAdd(a, b)
+  getGDNativeAPI().quatOperatorAdd(a, b).toQuat()

 proc `+=`*(a: var Quat, b: Quat) {.inline.} =
  a = a + b

 proc `-`*(a, b: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatOperatorSubtract(a, b)
+  getGDNativeAPI().quatOperatorSubtract(a, b).toQuat()

 proc `-=`* (a: var Quat, b: Quat) {.inline.} =
  a = a - b

 proc `/`*(self: Quat; b: float32): Quat {.inline.} =
-  getGDNativeAPI().quatOperatorDivide(self, b)
+  getGDNativeAPI().quatOperatorDivide(self, b).toQuat()

 proc `/=`*(self: var Quat, b: float32) {.inline.} =
  self = self / b
@ -81,4 +81,4 @@ proc `==`*(a, b: Quat): bool {.inline.} =
  getGDNativeAPI().quatOperatorEqual(a, b)

 proc `-`*(self: Quat): Quat {.inline.} =
-  getGDNativeAPI().quatOperatorNeg(self)
+  getGDNativeAPI().quatOperatorNeg(self).toQuat()
--- a/godot/core/rect2.nim
+++ b/godot/core/rect2.nim
@ -3,7 +3,7 @@
 import hashes

 import vector2
-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi

 {.push stackTrace: off.}
--- a/godot/core/rids.nim
+++ b/godot/core/rids.nim
@ -2,7 +2,7 @@

 import hashes

-import godotcoretypes, internal.godotinternaltypes, gdnativeapi
+import godotcoretypes, internal/godotinternaltypes, gdnativeapi

 proc initRID*(): RID {.inline.} =
  getGDNativeAPI().ridNew(result)
--- a/godot/core/transform2d.nim
+++ b/godot/core/transform2d.nim
@ -2,7 +2,7 @@

 import hashes, vector2

-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi

 proc initTransform2D*(): Transform2D {.inline.} =
@ -21,59 +21,59 @@ proc hash*(self: Transform2D): Hash {.inline, noinit.} =
  !$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash())

 proc inverse*(self: Transform2D): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DInverse(self)
+  getGDNativeAPI().transform2DInverse(self).toTransform2D()

 proc affineInverse*(self: Transform2D): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DAffineInverse(self)
+  getGDNativeAPI().transform2DAffineInverse(self).toTransform2D()

 proc rotation*(self: Transform2D): float32 {.inline.} =
  getGDNativeAPI().transform2DGetRotation(self)

 proc origin*(self: Transform2D): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DGetOrigin(self)
+  getGDNativeAPI().transform2DGetOrigin(self).toVector2()

 proc scale*(self: Transform2D): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DGetScale(self)
+  getGDNativeAPI().transform2DGetScale(self).toVector2()

 proc orthonormalized*(self: Transform2D): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DOrthonormalized(self)
+  getGDNativeAPI().transform2DOrthonormalized(self).toTransform2D()

 proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DRotated(self, phi)
+  getGDNativeAPI().transform2DRotated(self, phi).toTransform2D()

 proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DScaled(self, scale)
+  getGDNativeAPI().transform2DScaled(self, scale).toTransform2D()

 proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DTranslated(self, offset)
+  getGDNativeAPI().transform2DTranslated(self, offset).toTransform2D()

 proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DXformVector2(self, v)
+  getGDNativeAPI().transform2DXformVector2(self, v).toVector2()

 proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DXformInvVector2(self, v)
+  getGDNativeAPI().transform2DXformInvVector2(self, v).toVector2()

 proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DBasisXformVector2(self, v)
+  getGDNativeAPI().transform2DBasisXformVector2(self, v).toVector2()

 proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
-  getGDNativeAPI().transform2DBasisXformInvVector2(self, v)
+  getGDNativeAPI().transform2DBasisXformInvVector2(self, v).toVector2()

 proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
-  getGDNativeAPI().transform2DXformRect2(self, rect)
+  getGDNativeAPI().transform2DXformRect2(self, rect).toRect2()

 proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
-  getGDNativeAPI().transform2DXformInvRect2(self, rect)
+  getGDNativeAPI().transform2DXformInvRect2(self, rect).toRect2()

 proc interpolateWith*(self, m: Transform2D;
                      c: float32): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DInterpolateWith(self, m, c)
+  getGDNativeAPI().transform2DInterpolateWith(self, m, c).toTransform2D()

 proc `==`*(a, b: Transform2D): bool {.inline.} =
  getGDNativeAPI().transform2DOperatorEqual(a, b)

 proc `*`*(a, b: Transform2D): Transform2D {.inline.} =
-  getGDNativeAPI().transform2DOperatorMultiply(a, b)
+  getGDNativeAPI().transform2DOperatorMultiply(a, b).toTransform2D()

 proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} =
  a = a * b
--- a/godot/core/transforms.nim
+++ b/godot/core/transforms.nim
@ -2,7 +2,7 @@

 import hashes

-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi
 import basis, vector3

@ -27,50 +27,50 @@ proc hash*(self: Transform): Hash {.inline.} =
  !$(self.basis.hash() !& self.origin.hash())

 proc inverse*(self: Transform): Transform {.inline.} =
-  getGDNativeAPI().transformInverse(self)
+  getGDNativeAPI().transformInverse(self).toTransform()

 proc affineInverse*(self: Transform): Transform {.inline.} =
-  getGDNativeAPI().transformAffineInverse(self)
+  getGDNativeAPI().transformAffineInverse(self).toTransform()

 proc orthonormalized*(self: Transform): Transform {.inline.} =
-  getGDNativeAPI().transformOrthonormalized(self)
+  getGDNativeAPI().transformOrthonormalized(self).toTransform()

 proc rotated*(self: Transform; axis: Vector3;
              phi: float32): Transform {.inline.} =
-  getGDNativeAPI().transformRotated(self, axis, phi)
+  getGDNativeAPI().transformRotated(self, axis, phi).toTransform()

 proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} =
-  getGDNativeAPI().transformScaled(self, scale)
+  getGDNativeAPI().transformScaled(self, scale).toTransform()

 proc translated*(self: Transform; offset: Vector3): Transform {.inline.} =
-  getGDNativeAPI().transformTranslated(self, offset)
+  getGDNativeAPI().transformTranslated(self, offset).toTransform()

 proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} =
-  getGDNativeAPI().transformLookingAt(self, target, up)
+  getGDNativeAPI().transformLookingAt(self, target, up).toTransform()

 proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} =
-  getGDNativeAPI().transformXformPlane(self, plane)
+  getGDNativeAPI().transformXformPlane(self, plane).toPlane()

 proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} =
-  getGDNativeAPI().transformXformInvPlane(self, plane)
+  getGDNativeAPI().transformXformInvPlane(self, plane).toPlane()

 proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().transformXformVector3(self, v)
+  getGDNativeAPI().transformXformVector3(self, v).toVector3()

 proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
-  getGDNativeAPI().transformXformInvVector3(self, v)
+  getGDNativeAPI().transformXformInvVector3(self, v).toVector3()

 proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} =
-  getGDNativeAPI().transformXformAABB(self, rect)
+  getGDNativeAPI().transformXformAABB(self, rect).toAABB()

 proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} =
-  getGDNativeAPI().transformXformInvAABB(self, rect)
+  getGDNativeAPI().transformXformInvAABB(self, rect).toAABB()

 proc `==`*(self: Transform; b: Transform): bool {.inline.} =
  getGDNativeAPI().transformOperatorEqual(self, b)

 proc `*`*(self, other: Transform): Transform {.inline.} =
-  getGDNativeAPI().transformOperatorMultiply(self, other)
+  getGDNativeAPI().transformOperatorMultiply(self, other).toTransform()

 proc `*=`*(self: var Transform, other: Transform) {.inline.} =
  self = self * other
--- a/godot/core/variants.nim
+++ b/godot/core/variants.nim
@ -1,9 +1,9 @@
 import tables, hashes

 import godotcoretypes
-import internal.godotinternaltypes, internal.godotvariants,
-       internal.godotstrings, internal.godotdictionaries,
-       internal.godotarrays
+import internal/godotinternaltypes, internal/godotvariants,
+       internal/godotstrings, internal/godotdictionaries,
+       internal/godotarrays

 type
  Variant* = ref object
@ -73,9 +73,10 @@ proc newVariant*(r: cdouble): Variant {.inline.} =

 proc newVariant*(s: string): Variant {.inline.} =
  new(result, variantFinalizer)
+  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
    if s.isNil:
      initGodotVariant(result.godotVariant)
-  else:
+      return
  var godotStr = s.toGodotString()
  initGodotVariant(result.godotVariant, godotStr)
  godotStr.deinit()
--- a/godot/core/vector2.nim
+++ b/godot/core/vector2.nim
@ -2,9 +2,11 @@

 import math, godotbase, hashes

-import internal.godotinternaltypes, internal.godotstrings
+import internal/godotinternaltypes, internal/godotstrings
 import godotcoretypes, gdnativeapi

+const EPSILON = 0.00001'f32
+
 {.push stackTrace: off.}

 proc vec2*(): Vector2 {.inline, noinit.} =
@ -199,4 +201,14 @@ proc clamped*(self: Vector2; length: float32): Vector2 {.noinit.} =
    result /= len
    result *= length

+proc moveToward*(vFrom, to: Vector2, delta: float32): Vector2 =
+  let
+    vd = to - vFrom
+    vLen = vd.length
+
+  if vLen <= delta or vLen < EPSILON:
+    result = to
+  else:
+    result = vFrom + (vd / vLen) * delta
+
 {.pop.} # stackTrace: off
--- a/godot/core/vector3.nim
+++ b/godot/core/vector3.nim
@ -3,6 +3,8 @@
 import math, hashes
 import godotbase, godotcoretypes

+const EPSILON = 0.00001'f32
+
 {.push stackTrace: off.}

 proc vec3*(): Vector3 {.inline.} =
@ -239,4 +241,14 @@ proc cubicInterpolate*(self, b, preA, postB: Vector3;
            (2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 +
            (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3)

+proc moveToward*(vFrom, to: Vector3, delta: float32): Vector3 =
+  let
+    vd = to - vFrom
+    vLen = vd.length
+
+  if vLen <= delta or vLen < EPSILON:
+    result = to
+  else:
+    result = vFrom + (vd / vLen) * delta
+
 {.pop.} # stackTrace: off
--- a/godot/gdnativeapi.nim
+++ b/godot/gdnativeapi.nim
--- a/godot/godot.nim
+++ b/godot/godot.nim
@ -1,14 +1,14 @@
 # Copyright 2018 Xored Software, Inc.

-import core.godotbase, godotinternal
-import core.godotcoretypes
-import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes,
-       core.quats
-import core.aabb, core.basis, core.transforms, core.colors, core.nodepaths,
-       core.rids
-import core.dictionaries, core.arrays, core.poolarrays, core.variants
+import core/godotbase, godotinternal
+import core/godotcoretypes
+import core/vector2, core/rect2, core/vector3, core/transform2d, core/planes,
+       core/quats
+import core/aabb, core/basis, core/transforms, core/colors, core/nodepaths,
+       core/rids
+import core/dictionaries, core/arrays, core/poolarrays, core/variants

-import nim.godotmacros, nim.godotnim
+import nim/godotmacros, nim/godotnim

 export godotbase, godotcoretypes, vector2, rect2, vector3, transform2d, planes,
       quats, aabb, basis, transforms, colors, nodepaths, rids, dictionaries,
--- a/godot/godotapigen.nim
+++ b/godot/godotapigen.nim
@ -1,12 +1,31 @@
 # Copyright 2018 Xored Software, Inc.

-import streams, json, os, strutils, times, sets, tables
+import streams, json, os, strutils, times, sets, tables, options
 import sequtils, algorithm
-import compiler.ast, compiler.renderer, compiler.idents, compiler.astalgo
+import compiler/ast, compiler/renderer, compiler/idents, compiler/astalgo
+
+include "internal/backwardcompat.inc.nim"
+
+when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0):
+  import compiler/lineinfos
+
+when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0):
+  var gic = newIdentCache()
+
+  proc getIdent(ident: string): PIdent =
+    getIdent(gic, ident)

 proc ident(ident: string): PNode =
-  result = newNode(nkIdent)
-  result.ident = getIdent(ident)
+  result = PNode(kind: nkIdent, ident: getIdent(ident))
+
+proc newPNode(kind: TNodeKind): PNode =
+  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
+    result = newNode(kind)
+  else:
+    result = PNode(kind: kind)
+    result.info.fileIndex = InvalidFileIdx
+    result.info.col = int16(-1)
+    result.info.line = uint16(0)

 proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} =
  for other in others:
@ -15,37 +34,37 @@ proc addChain(node: PNode, others: varargs[PNode]): PNode {.discardable.} =

 proc newIdentDefs(name, typ: PNode,
                  defaultVal: PNode = nil): PNode =
-  result = newNode(nkIdentDefs)
+  result = newPNode(nkIdentDefs)
  result.add(name)
  result.add(typ)
  if defaultVal.isNil:
-    result.add(newNode(nkEmpty))
+    result.add(newPNode(nkEmpty))
  else:
    result.add(defaultVal)

-proc newProc(name: PNode, params: openArray[PNode], body = newNode(nkEmpty),
+proc newProc(name: PNode, params: openArray[PNode], body = newPNode(nkEmpty),
             procType = nkProcDef): PNode =
-  result = newNode(procType)
+  result = newPNode(procType)
  result.add(name)
-  result.add(newNode(nkEmpty))
-  result.add(newNode(nkEmpty))
-  let formalParams = newNode(nkFormalParams)
+  result.add(newPNode(nkEmpty))
+  result.add(newPNode(nkEmpty))
+  let formalParams = newPNode(nkFormalParams)
  for param in params:
    formalParams.add(param)
  result.add(formalParams)
-  result.add(newNode(nkEmpty))
-  result.add(newNode(nkEmpty))
+  result.add(newPNode(nkEmpty))
+  result.add(newPNode(nkEmpty))
  result.add(body)

 proc newIfStmt(condition, body: PNode): PNode =
-  result = newNode(nkIfStmt)
-  let branch = newNode(nkElifBranch)
+  result = newPNode(nkIfStmt)
+  let branch = newPNode(nkElifBranch)
  result.add(branch)
  branch.add(condition)
  branch.add(body)

 proc newCall(theProc: PNode, args: varargs[PNode]): PNode =
-  result = newNode(nkCall)
+  result = newPNode(nkCall)
  result.add(theProc)
  for arg in args:
    result.add(arg)
@ -54,66 +73,66 @@ proc newCall(theProc: string, args: varargs[PNode]): PNode =
  newCall(ident(theProc), args)

 proc newStrLit(s: string): PNode =
-  result = newNode(nkStrLit)
+  result = newPNode(nkStrLit)
  result.strVal = s

 proc newRStrLit(s: string): PNode =
-  result = newNode(nkRStrLit)
+  result = newPNode(nkRStrLit)
  result.strVal = s

 proc newCStringLit(s: string): PNode =
-  newNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s))
+  newPNode(nkCallStrLit).addChain(ident("cstring"), newRStrLit(s))

 proc newIntLit(val: BiggestInt): PNode =
-  result = newNode(nkIntLit)
+  result = newPNode(nkIntLit)
  result.intVal = val

 proc newInt64Lit(val: BiggestInt): PNode =
-  result = newNode(nkInt64Lit)
+  result = newPNode(nkInt64Lit)
  result.intVal = val

 proc newFloatLit(val: BiggestFloat): PNode =
-  result = newNode(nkFloatLit)
+  result = newPNode(nkFloatLit)
  result.floatVal = val

 proc newFloat64Lit(val: BiggestFloat): PNode =
-  result = newNode(nkFloat64Lit)
+  result = newPNode(nkFloat64Lit)
  result.floatVal = val

 proc newNilLit(): PNode =
-  result = newNode(nkNilLit)
+  result = newPNode(nkNilLit)

 proc newDotExpr(left, right: PNode): PNode =
-  result = newNode(nkDotExpr)
+  result = newPNode(nkDotExpr)
  result.add(left)
  result.add(right)

 proc newCommand(left, right: PNode): PNode =
-  result = newNode(nkCommand)
+  result = newPNode(nkCommand)
  result.add(left)
  result.add(right)

 proc infix(left, op, right: PNode): PNode =
-  result = newNode(nkInfix)
+  result = newPNode(nkInfix)
  result.add(op)
  result.add(left)
  result.add(right)

 proc postfix(left: PNode, op: string): PNode =
-  result = newNode(nkPostfix)
+  result = newPNode(nkPostfix)
  result.add(ident(op))
  result.add(left)

 proc prefix(op: string, right: PNode): PNode =
-  result = newNode(nkPrefix)
+  result = newPNode(nkPrefix)
  result.add(ident(op))
  result.add(right)

 proc newBracketExpr(first, bracket: PNode): PNode =
-  newNode(nkBracketExpr).addChain(first, bracket)
+  newPNode(nkBracketExpr).addChain(first, bracket)

 proc newEmptyNode(): PNode =
-  newNode(nkEmpty)
+  newPNode(nkEmpty)

 type GodotType = ref object
  name: string
@ -139,19 +158,19 @@ proc findCommonRoot(typeRegistry: Table[string, GodotType],

  var idx = 0
  while true:
-    var curType: string
+    var curType = none(string)
    var allEqual = true
    for chain in chains:
      if idx >= chain.len:
        allEqual = false
        break
-      if curType.isNil:
-        curType = chain[idx]
-      elif curType != chain[idx]:
+      if curType.isNone:
+        curType = some(chain[idx])
+      elif curType.get != chain[idx]:
        allEqual = false
        break
    if allEqual:
-      result = curType
+      result = curType.get
    else:
      break
    inc idx
@ -206,42 +225,42 @@ proc toNimStyle(name: string): string =

 proc newRefTypeNode(typeSection: PNode, typ, base, doc: string,
                    isExported = true) =
-  let typeDef = newNode(nkTypeDef)
+  let typeDef = newPNode(nkTypeDef)
  typeSection.add(typeDef)
  if isExported:
    typeDef.add(postfix(ident(typ), "*"))
  else:
    typeDef.add(ident(typ))

-  typeDef.add(newNode(nkEmpty)) # generic
-  let objTy = newNode(nkObjectTy)
-  let refTy = newNode(nkRefTy)
+  typeDef.add(newPNode(nkEmpty)) # generic
+  let objTy = newPNode(nkObjectTy)
+  let refTy = newPNode(nkRefTy)
  refTy.add(objTy)
  typeDef.add(refTy)

-  objTy.add(newNode(nkEmpty))
-  let inherit = newNode(nkOfInherit)
+  objTy.add(newPNode(nkEmpty))
+  let inherit = newPNode(nkOfInherit)
  inherit.add(ident(base))
  objTy.add(inherit)

-  if not doc.isNil:
-    let recList = newNode(nkRecList)
-    let docNode = newNode(nkCommentStmt)
+  if doc.len > 0:
+    let recList = newPNode(nkRecList)
+    let docNode = newPNode(nkCommentStmt)
    docNode.comment = doc
    recList.add(docNode)
    objTy.add(recList)
  else:
-    objTy.add(newNode(nkEmpty))
+    objTy.add(newPNode(nkEmpty))

 proc makeConstSection(constObj: JsonNode): PNode =
  if constObj.len == 0:
-    return newNode(nkEmpty)
+    return newPNode(nkEmpty)

-  result = newNode(nkConstSection)
+  result = newPNode(nkConstSection)
  for field, val in constObj:
-    let def = newNode(nkConstDef)
+    let def = newPNode(nkConstDef)
    def.add(postfix(ident(field), "*"))
-    def.add(newNode(nkEmpty)) # infer type
+    def.add(newPNode(nkEmpty)) # infer type
    var valNode: PNode
    if val.kind == JInt:
      valNode = newInt64Lit(val.num)
@ -251,7 +270,7 @@ proc makeConstSection(constObj: JsonNode): PNode =
    elif val.kind == JBool:
      valNode = ident($val.bval)
    elif val.kind == JString:
-      valNode = newNode(nkStrLit)
+      valNode = newPNode(nkStrLit)
      valNode.strVal = val.str
    else:
      raise newException(ValueError, "Unexpected constant kind: " & $val.kind)
@ -275,12 +294,12 @@ type
    godotName: string
    typ: GodotType
    args: seq[MethodArg]
-    returnType: string
+    returnType: Option[string]
    isVirtual: bool
    isBase: bool
    isDiscardable: bool

-const standardTypes = toSet(
+const standardTypes = toHashSet(
  ["bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32",
   "uint64", "Error",
   "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2",
@ -289,26 +308,33 @@ const standardTypes = toSet(
   "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray",
   "PoolVector2Array", "PoolVector3Array", "PoolColorArray"])

-const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32",
+const variantPrimitives = [
+   "bool", "cint", "int", "uint8", "int8", "uint16", "int16", "uint32", "int32",
+   "uint64", "Error",
+   "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2",
+   "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform",
+   "Color", "RID"]
+
+const smallIntTypes = toHashSet(["uint8", "int8", "uint16", "int16", "uint32",
                              "int32", "cint", "int", "Error"])
-const int64Types = toSet(["uint64", "int64"])
+const int64Types = toHashSet(["uint64", "int64"])
 const intTypes = union(smallIntTypes, int64Types)
-const float64Types = toSet(["float64", "cdouble"])
-const float32Types = toSet(["float32", "cfloat"])
+const float64Types = toHashSet(["float64", "cdouble"])
+const float32Types = toHashSet(["float32", "cfloat"])
 const floatTypes = union(float64Types, float32Types)
-const arrayTypes = toSet(["Array", "PoolByteArray",
+const arrayTypes = toHashSet(["Array", "PoolByteArray",
  "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array",
  "PoolVector3Array", "PoolColorArray"])
 const wrapperTypes = union(arrayTypes,
-                           toSet(["NodePath", "Dictionary", "Variant"]))
+                           toHashSet(["NodePath", "Dictionary", "Variant"]))

 proc getInternalPtr(varName: PNode, typ: string): PNode =
-  assert(typ in wrapperTypes)
+  assert(typ in wrapperTypes or typ == "Object")
  result = newDotExpr(varName, ident("godot" & typ))

 proc newNilCheck(ident, toAssign: PNode): PNode =
  newIfStmt(newCall("isNil", ident),
-    newNode(nkAsgn).addChain(ident).addChain(
+    newPNode(nkAsgn).addChain(ident).addChain(
      toAssign
    )
  )
@ -381,6 +407,8 @@ proc makeDefaultValue(arg: MethodArg): PNode =
        result = newCall("newVariant")
      else:
        failed = true
+    elif arg.typ == "Dictionary":
+      result = newCall("newDictionary")
    else:
      failed = true

@ -397,12 +425,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
                      meth: MethodInfo, withImplementation: bool) =
  var body: PNode
  if not withImplementation:
-    body = newNode(nkEmpty)
+    body = newPNode(nkEmpty)
  elif meth.godotName == "_init" and meth.typ.godotName == "Object":
    # It's not real (calling it crashes) and will be removed later,
    # but we use init() convention in Nim, so it needs to work.
-    body = newNode(nkStmtList).addChain(
-      newNode(nkDiscardStmt).addChain(newNode(nkEmpty)))
+    body = newPNode(nkStmtList).addChain(
+      newPNode(nkDiscardStmt).addChain(newPNode(nkEmpty)))
  else:
    let methGodotName = if meth.godotName.startsWith('_'):
                          "underscore" & meth.godotName[1..^1]
@ -413,12 +441,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
    if methodBindName[0].isUpperAscii():
      methodBindName[0] = methodBindName[0].toLowerAscii()
    if methodBindName notin methodBindRegistry:
-      let methodBindDecl = newNode(nkVarSection).addChain(
+      let methodBindDecl = newPNode(nkVarSection).addChain(
        newIdentDefs(
-          newNode(nkPragmaExpr).addChain(
+          newPNode(nkPragmaExpr).addChain(
            ident(methodBindName)).addChain(
-              newNode(nkPragma).addChain(ident("threadvar"))),
-          newNode(nkPtrTy).addChain(ident("GodotMethodBind"))
+              newPNode(nkPragma).addChain(ident("threadvar"))),
+          newPNode(nkPtrTy).addChain(ident("GodotMethodBind"))
        ))
      tree.add(methodBindDecl)
      methodBindRegistry.incl(methodBindName)
@ -427,8 +455,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
      newCall("getMethod", newCStringLit(meth.typ.godotName),
        newCStringLit(meth.godotName))
    )
-    let vars = newNode(nkVarSection)
-    var varargsName: string
+    let vars = newPNode(nkVarSection)
+    var varargsName = none(string)
    var isVarargs: bool
    var staticArgsLen: int
    var argLenNode = newIntLit(0)
@ -436,54 +464,90 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
    if meth.args.len > 0:
      for idx, arg in meth.args:
        if arg.kind == ArgKind.VarArgs:
-          varargsName = arg.name
+          varargsName = some(arg.name)
          isVarargs = true
          vars.add(newIdentDefs(ident("callError"), ident("VariantCallError")))
        elif arg.kind == ArgKind.Bound:
          let argName = boundArgName(idx)
          vars.add(newIdentDefs(
-            ident(argName), newNode(nkEmpty), arg.makeDefaultValue()))
+            ident(argName), newPNode(nkEmpty), arg.makeDefaultValue()))

-      let argsAlloc = newNode(nkCast).addChain(
-        newNode(nkPtrTy).addChain(
-          newNode(nkBracketExpr).addChain(
+      let argsAlloc = newPNode(nkCast).addChain(
+        newPNode(nkPtrTy).addChain(
+          newPNode(nkBracketExpr).addChain(
            ident("array"), ident("MAX_ARG_COUNT"),
-            if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant"))
+            if isVarargs: newPNode(nkPtrTy).addChain(ident("GodotVariant"))
            else: ident("pointer"))))
-      staticArgsLen = if varargsName.isNil: meth.args.len
+      staticArgsLen = if varargsName.isNone: meth.args.len
                      else: meth.args.len - 1
-      if not varargsName.isNil:
+      if varargsName.isSome:
        argLenNode = newCall("cint",
                      infix(newIntLit(staticArgsLen),
                            ident("+"),
-                            newDotExpr(ident(varargsName), ident("len"))))
+                            newDotExpr(ident(varargsName.get), ident("len"))))
        argsAlloc.add(newCall("godotAlloc", newCall("cint", infix(
-          newCall("sizeof", ident("Variant")), ident("*"),
-          newNode(nkPar).addChain(argLenNode))))
+          newCall("sizeof", newPNode(nkPtrTy).addChain(ident("GodotVariant"))), ident("*"),
+          newPNode(nkPar).addChain(argLenNode))))
        )
      else:
        argLenNode = newCall("cint", newIntLit(staticArgsLen))
        vars.add(newIdentDefs(
          ident("argsStatic"),
-          newNode(nkBracketExpr).addChain(
+          newPNode(nkBracketExpr).addChain(
            ident("array"), newIntLit(staticArgsLen), ident("pointer")),
-          newNode(nkEmpty)))
+          newPNode(nkEmpty)))
        argsAlloc.add(newCommand(ident("addr"), ident("argsStatic")))
-      vars.add(newIdentDefs(argsName, newNode(nkEmpty), argsAlloc))
+      vars.add(newIdentDefs(argsName, newPNode(nkEmpty), argsAlloc))

-    let argConversions = newNode(nkStmtList)
+    let argConversions = newPNode(nkStmtList)
+    let destructors = newPNode(nkStmtList)
    for idx, arg in meth.args:
      var argName = if arg.kind == ArgKind.Bound: ident(boundArgName(idx))
                    else: ident(arg.name)
      if arg.kind == ArgKind.VarArgs:
-        argName = newNode(nkBracketExpr).addChain(
-          ident(varargsName),
+        argName = newPNode(nkBracketExpr).addChain(
+          ident(varargsName.get),
          infix(ident("idx"), ident("-"), newIntLit(staticArgsLen)))
      let argIdx = if arg.kind == ArgKind.VarArgs: ident("idx") else: newIntLit(idx)
      let isStandardType = arg.typ in standardTypes
      let isWrappedType = arg.typ in wrapperTypes
-      let convArg = if not varargsName.isNil:
-                      getInternalPtr(newCall("toVariant", argName), "Variant")
+      let convArg =
+        if varargsName.isSome:
+          let isAlreadyVariant = arg.typ == "Variant"
+          let variantIdent = if isAlreadyVariant: getInternalPtr(argName, "Variant")
+                             else: ident("variant" & $idx)
+          if not isAlreadyVariant:
+            argConversions.add(newPNode(nkVarSection).addChain(
+              newIdentDefs(variantIdent, ident("GodotVariant"), newEmptyNode())
+            ))
+            destructors.add(
+              newCall("deinit", variantIdent)
+            )
+            if arg.typ in variantPrimitives:
+              argConversions.add(
+                newCall("initGodotVariant", variantIdent, argName)
+              )
+            elif arg.typ in wrapperTypes or arg.typ == "Object":
+              argConversions.add(
+                newCall("initGodotVariant", variantIdent, getInternalPtr(argName, arg.typ))
+              )
+            elif arg.typ == "string":
+              let stringIdent = ident("variantString" & $idx)
+              argConversions.addChain(
+                newPNode(nkVarSection).addChain(
+                  newIdentDefs(stringIdent, ident("GodotString"), newCall("toGodotString", argName))
+                )
+              ).addChain(
+                newCall("initGodotVariant", variantIdent, stringIdent)
+              )
+              destructors.add(newCall("deinit", stringIdent))
+            else:
+              raise newException(ValueError,
+                "Non-standard type $# for varargs params of method $# of type $#" %
+                [arg.typ, meth.godotName, meth.typ.godotName])
+
+          if isAlreadyVariant: variantIdent
+          else: newCall("addr", variantIdent)
        elif isWrappedType: getInternalPtr(argName, arg.typ)
        elif isStandardType: newCall("unsafeAddr", argName)
        elif arg.typ == "string": newCall("unsafeAddr",
@ -493,21 +557,21 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
        raise newException(ValueError,
          "Non-standard type $# for varargs params of method $# of type $#" %
            [arg.typ, meth.godotName, meth.typ.godotName])
-      if not isStandardType and varargsName.isNil:
+      if not isStandardType and varargsName.isNone:
        if arg.typ == "string":
-          argConversions.add(newNode(nkVarSection).addChain(
+          argConversions.add(newPNode(nkVarSection).addChain(
            newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(),
                         newCall("toGodotString", argName))))
        else:
          let objVal = newIfStmt(
            prefix("not", newDotExpr(argName, ident"isNil")),
            newDotExpr(argName, ident("godotObject"))
-          ).addChain(newNode(nkElse).addChain(newNilLit()))
-          argConversions.add(newNode(nkLetSection).addChain(
+          ).addChain(newPNode(nkElse).addChain(newNilLit()))
+          argConversions.add(newPNode(nkLetSection).addChain(
            newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), objVal)))
-      let argAsgn = newNode(nkAsgn).addChain(
-        newNode(nkBracketExpr).addChain(
-          newNode(nkBracketExpr).addChain(argsName), argIdx),
+      let argAsgn = newPNode(nkAsgn).addChain(
+        newPNode(nkBracketExpr).addChain(
+          newPNode(nkBracketExpr).addChain(argsName), argIdx),
          convArg
      )
      if arg.kind != ArgKind.VarArgs:
@ -515,14 +579,14 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
          argAsgn
        )
      else:
-        argConversions.add(newNode(nkVarSection).addChain(
-          newIdentDefs(ident("idx"), newNode(nkEmpty),
+        argConversions.add(newPNode(nkVarSection).addChain(
+          newIdentDefs(ident("idx"), newPNode(nkEmpty),
                       newIntLit(staticArgsLen))))
-        let argLoop = newNode(nkWhileStmt)
+        let argLoop = newPNode(nkWhileStmt)
        argConversions.add(argLoop)
        argLoop.add(infix(ident("idx"), ident("<"), argLenNode)
        )
-        argLoop.add(newNode(nkStmtList).addChain(
+        argLoop.add(newPNode(nkStmtList).addChain(
          argAsgn,
          newCommand(ident("inc"), ident("idx"))))

@ -531,26 +595,26 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
      newDotExpr(ident(methodBindName),
                 ident(if isVarargs: "call" else: "ptrCall")),
      newDotExpr(ident("self"), ident("godotObject")),
-      if meth.args.len > 0: argsName else: newNode(nkNilLit),
+      if meth.args.len > 0: argsName else: newPNode(nkNilLit),
      argLenNode,
      if not isVarargs: ident(retName) else: ident("callError")
    )
    if not isVarargs:
      theCall.sons.delete(3)
    let freeCall = newCall("godotFree", argsName)
-    body = newNode(nkStmtList)
+    body = newPNode(nkStmtList)
    if meth.typ.isSingleton:
      let varName = singletonName(meth.typ.name)
      body.add(newNilCheck(varName, newCall(
        newBracketExpr(ident("getSingleton"), ident(meth.typ.name)))))
-      body.add(newNode(nkLetSection).addChain(newIdentDefs(
-        ident("self"), newNode(nkEmpty), varName
+      body.add(newPNode(nkLetSection).addChain(newIdentDefs(
+        ident("self"), newPNode(nkEmpty), varName
      )))
    body.add(nilCheck)
    body.add(vars)
    body.add(argConversions)
    if not isVarargs:
-      let retPtrDecl = newNode(nkVarSection).addChain(
+      let retPtrDecl = newPNode(nkVarSection).addChain(
        newIdentDefs(ident(retName), ident("pointer"), newEmptyNode())
      )
      body.add(retPtrDecl)
@ -560,105 +624,109 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
    var isStringRet: bool
    var isWrapperRet: bool
    let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName)
-    if not meth.returnType.isNil and not isVarargs:
+    if meth.returnType.isSome and not isVarargs:
+      let returnType = meth.returnType.get
      var addrToAssign = newCall("addr", retValIdent)
-      if meth.returnType in smallIntTypes:
+      if returnType in smallIntTypes:
        isConversionRet = true
-        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+        body.add(newPNode(nkVarSection).addChain(newIdentDefs(
          retValIdent, ident("int64"),
        )))
-      elif meth.returnType in float32Types:
+      elif returnType in float32Types:
        isConversionRet = true
-        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+        body.add(newPNode(nkVarSection).addChain(newIdentDefs(
          retValIdent, ident("float64"),
        )))
-      elif meth.returnType in wrapperTypes:
+      elif returnType in wrapperTypes:
        isWrapperRet = true
-        body.add(newNode(nkVarSection).addChain(newIdentDefs(
-          retValIdent, ident("Godot" & meth.returnType),
+        body.add(newPNode(nkVarSection).addChain(newIdentDefs(
+          retValIdent, ident("Godot" & returnType),
        )))
-      elif meth.returnType in standardTypes:
+        if returnType != "NodePath":
+          body.add(newCall("initGodot" & returnType, retValIdent))
+      elif returnType in standardTypes:
        addrToAssign = newCall("addr", ident("result"))
-      elif meth.returnType == "string":
+      elif returnType == "string":
        isStringRet = true
-        body.add(newNode(nkVarSection).addChain(newIdentDefs(
+        body.add(newPNode(nkVarSection).addChain(newIdentDefs(
          retValIdent, ident("GodotString"),
        )))
-      elif meth.returnType != "void":
+      elif returnType != "void":
        isObjRet = true
-        body.add(newNode(nkVarSection).addChain(newIdentDefs(
-          retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")),
+        body.add(newPNode(nkVarSection).addChain(newIdentDefs(
+          retValIdent, newPNode(nkPtrTy).addChain(ident("GodotObject")),
        )))
-      body.add(newNode(nkAsgn).addChain(ident(retName), addrToAssign))
+      body.add(newPNode(nkAsgn).addChain(ident(retName), addrToAssign))

    if not isVarargs:
      body.add(theCall)
    else:
-      if not meth.returnType.isNil:
+      if meth.returnType.isSome:
        isVariantRet = true
-      let callStmt = newNode(nkLetSection).addChain(
+      let callStmt = newPNode(nkLetSection).addChain(
        newIdentDefs(
-          newNode(nkPragmaExpr).addChain(
-            ident(retName), newNode(nkPragma).addChain(ident("used"))),
-          newNode(nkEmpty), theCall))
+          newPNode(nkPragmaExpr).addChain(
+            ident(retName), newPNode(nkPragma).addChain(ident("used"))),
+          newPNode(nkEmpty), theCall))
      body.add(callStmt)

-    if varargsName.isNil:
+    if varargsName.isNone:
      for idx, arg in meth.args:
        if arg.typ == "string":
          body.add(newCall("deinit", ident("argToPassToGodot" & $idx)))

-    if meth.args.len > 0 and not varargsName.isNil:
+    if varargsName.isSome:
+      if meth.args.len > 0:
        body.add(freeCall)
-    if not varargsName.isNil:
+      body.add(destructors)
      let errCheck = newIfStmt(
        infix(newDotExpr(ident("callError"), ident("error")), ident("!="),
                 newDotExpr(ident("VariantCallErrorType"), ident("OK"))),
-        newNode(nkRaiseStmt).addChain(
+        newPNode(nkRaiseStmt).addChain(
          newCall("newCallError", ident("callError")))
      )
      body.add(errCheck)
    if isVariantRet:
-      let convErrDef = newNode(nkLetSection).addChain(
-          newIdentDefs(ident("convErr"), newNode(nkEmpty),
+      let convErrDef = newPNode(nkLetSection).addChain(
+          newIdentDefs(ident("convErr"), newPNode(nkEmpty),
              newCall("fromVariant", ident("result"),
                      newCall("newVariant", retValIdent))))
      let convCheck = newIfStmt(
        infix(ident("convErr"), ident("!="),
                 newDotExpr(ident("ConversionResult"), ident("OK"))),
-        newNode(nkRaiseStmt).addChain(
+        newPNode(nkRaiseStmt).addChain(
          newCall("newConversionError", ident("convErr")))
      )
      body.add(convErrDef)
      body.add(convCheck)
    if isStringRet:
-      body.add(newNode(nkAsgn).addChain(
+      body.add(newPNode(nkAsgn).addChain(
        ident("result"), prefix("$", retValIdent)))
      body.add(newCall("deinit", retValIdent))
    elif isConversionRet:
-      body.add(newNode(nkAsgn).addChain(
+      body.add(newPNode(nkAsgn).addChain(
        ident("result"),
-        newCall(meth.returnType, retValIdent)))
+        newCall(meth.returnType.get, retValIdent)))
    elif isWrapperRet:
-      body.add(newNode(nkAsgn).addChain(
+      body.add(newPNode(nkAsgn).addChain(
        ident("result"),
-        newCall("new" & meth.returnType, retValIdent)))
+        newCall("new" & meth.returnType.get, retValIdent)))
    elif isObjRet:
-      body.add(newNode(nkAsgn).addChain(ident("result"),
+      body.add(newPNode(nkAsgn).addChain(ident("result"),
               newCall(newBracketExpr(ident("asNimGodotObject"),
        newCall("type", ident("result"))),
        retValIdent, ident("false"), ident("true"))))
    elif isStringRet:
-      body.add(newNode(nkAsgn).addChain(ident("result"),
+      body.add(newPNode(nkAsgn).addChain(ident("result"),
                                        newCall("$", retValIdent)))

  let procType = if meth.isVirtual: nkMethodDef
                 else: nkProcDef
  var params = newSeqOfCap[PNode](meth.args.len + 2)
-  if not meth.returnType.isNil:
-    params.add(ident(meth.returnType))
+  if meth.returnType.isSome:
+    params.add(ident(meth.returnType.get))
  else:
-    params.add(newNode(nkEmpty))
+    params.add(newPNode(nkEmpty))
  if not meth.typ.isSingleton:
    params.add(newIdentDefs(ident("self"), ident(toNimType(meth.typ.name))))

@ -669,7 +737,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
      params.add(newIdentDefs(ident(arg.name), ident(arg.typ), defaultValue))
    of ArgKind.VarArgs:
      params.add(newIdentDefs(ident(arg.name),
-        newNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ))))
+        newPNode(nkBracketExpr).addChain(ident("varargs"), ident(arg.typ))))
    of ArgKind.Bound:
      discard

@ -677,14 +745,14 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
                         else: meth.name,
                         params, body, procType)
  if not withImplementation:
-    let pragma = newNode(nkPragma)
+    let pragma = newPNode(nkPragma)
    pragma.add(ident("gcsafe"))
-    pragma.add(newNode(nkExprColonExpr).addChain(ident("locks"),
+    pragma.add(newPNode(nkExprColonExpr).addChain(ident("locks"),
                                                newIntLit(0)))
    if meth.isVirtual and meth.isBase and meth.typ.name != "PhysicsBody":
      # Nim doesn't like `base` on PhysicsBody methods - wtf
      pragma.add(ident("base"))
-    if meth.isDiscardable and not meth.returnType.isNil:
+    if meth.isDiscardable and meth.returnType.isSome:
      pragma.add(ident("discardable"))
    procDecl.sons[4] = pragma
  tree.add(procDecl)
@ -729,9 +797,9 @@ proc getMethodInfo(methodObj: JsonNode, types: Table[string, GodotType],
        nimName = nimName & "Impl"

  let returnType = if methodObj["return_type"].str != "void":
-                      toNimType(types, methodObj["return_type"].str)
-                   else: nil
-  const discardableMethods = toSet(["emit_signal"])
+                      some(toNimType(types, methodObj["return_type"].str))
+                   else: none(string)
+  const discardableMethods = toHashSet(["emit_signal"])
  result = MethodInfo(
    name: ident(nimName),
    typ: typ,
@ -760,17 +828,17 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode,
      return
  let getterNameStr = toNimStyle(propertyObj["name"].str)
  let getterName = ident(getterNameStr)
-  let setterName = newNode(nkAccQuoted).addChain(ident(getterNameStr & "="))
+  let setterName = newPNode(nkAccQuoted).addChain(ident(getterNameStr & "="))

  let getter = findMethod(obj, propertyObj["getter"].str)
  let nimType = if getter.isNil: toNimType(types, propertyObj["type"].str)
-                else: getMethodInfo(getter, types, typ).returnType
+                else: getMethodInfo(getter, types, typ).returnType.get("void")
  let getterInfo = MethodInfo(
    name: getterName,
    typ: typ,
    godotName: propertyObj["getter"].str,
-    args: @[],
-    returnType: nimType
+    args: newSeq[MethodArg](),
+    returnType: some(nimType)
  )
  let setterInfo = MethodInfo(
    name: setterName,
@ -779,9 +847,11 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode,
    args: @[MethodArg(name: "val", typ: nimType)]
  )
  if "index" in propertyObj and propertyObj["index"] != newJInt(-1):
-    getterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]),
+    getterInfo.args =
+      @[MethodArg(defaultVal: newJString($propertyObj["index"]),
                  typ: "int", kind: ArgKind.Bound)] & getterInfo.args
-    setterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]),
+    setterInfo.args =
+      @[MethodArg(defaultVal: newJString($propertyObj["index"]),
                  typ: "int", kind: ArgKind.Bound)] & setterInfo.args
  generateMethod(tree, methodBindRegistry, getterInfo, withImplementation)
  generateMethod(tree, methodBindRegistry, setterInfo, withImplementation)
@ -839,15 +909,15 @@ proc typeNameToModuleName(name: string): string =
 proc newRegisterClassNode(typ: GodotType): PNode =
  newCall("registerClass",
    ident(typ.name),
-    newCStringLit(typ.godotName),
+    newStrLit(typ.godotName),
    ident("true") # isNative
  )

 proc genSingletonDecl(typ: string): PNode =
-  result = newNode(nkVarSection)
+  result = newPNode(nkVarSection)
  let name = singletonName(typ)
-  let threadvar = newNode(nkPragma).addChain(ident("threadvar"))
-  result.add(newIdentDefs(newNode(nkPragmaExpr).addChain(name, threadvar),
+  let threadvar = newPNode(nkPragma).addChain(ident("threadvar"))
+  result.add(newIdentDefs(newPNode(nkPragmaExpr).addChain(name, threadvar),
             ident(typ)))

 proc shouldExport(typ: GodotType, types: Table[string, GodotType]): bool =
@ -864,9 +934,9 @@ proc sortByDerivedCount(types: Table[string, GodotType]): seq[GodotType] =
 proc genTypeFile(types: Table[string, GodotType], targetDir: string) =
  let sortedTypes = sortByDerivedCount(types)

-  let godotApiTypesTree = newNode(nkStmtList)
-  godotApiTypesTree.add(newNode(nkImportStmt).addChain(ident("godot")))
-  let typeSection = newNode(nkTypeSection)
+  let godotApiTypesTree = newPNode(nkStmtList)
+  godotApiTypesTree.add(newPNode(nkImportStmt).addChain(ident("godot")))
+  let typeSection = newPNode(nkTypeSection)
  godotApiTypesTree.add(typeSection)

  for typ in sortedTypes:
@ -877,7 +947,7 @@ proc genTypeFile(types: Table[string, GodotType], targetDir: string) =
    if not typ.shouldExport(types): continue
    let regNode = newCall("registerClass",
      ident(typ.name),
-      newCStringLit(typ.godotName),
+      newStrLit(typ.godotName),
      ident("true") # isNative
    )
    godotApiTypesTree.add(regNode)
@ -888,10 +958,10 @@ proc genSingletonWithDerived(tree: PNode, typ: GodotType,
                             types: Table[string, GodotType]) =
  let sortedTypes = sortByDerivedCount(types)

-  var parents = initSet[string]()
+  var parents = initHashSet[string]()
  parents.incl(typ.name)

-  let typeDecl = newNode(nkTypeSection)
+  let typeDecl = newPNode(nkTypeSection)
  tree.add(typeDecl)
  proc genDecl(typ: GodotType) =
    newRefTypeNode(typeDecl, typ.name, typ.baseName, typ.doc,
@ -920,7 +990,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) =
    let className = godotClassName.replace("_", "")
    var baseClassName = obj["base_class"].str
    baseClassName = toNimType(baseClassName.replace("_", ""))
-    if baseClassName.isNil or baseClassName.len == 0:
+    if baseClassName.len == 0:
      baseClassName = "NimGodotObject"
    var doc = ""
    for attr in classAttributes:
@ -941,17 +1011,17 @@ proc genApi*(targetDir: string, apiJsonFile: string) =
  for typ in types.values():
    let moduleName = typeNameToModuleName(typ.name)
    echo "Generating ", moduleName, ".nim..."
-    let tree = newNode(nkStmtList)
-    let importStmt = newNode(nkImportStmt)
+    let tree = newPNode(nkStmtList)
+    let importStmt = newPNode(nkImportStmt)
    importStmt.add(ident("godot"))
    importStmt.add(ident("godottypes"))
    importStmt.add(ident("godotinternal"))
    tree.add(importStmt)
-    let exportStmt = newNode(nkExportStmt)
+    let exportStmt = newPNode(nkExportStmt)
    exportStmt.add(ident("godottypes"))
    tree.add(exportStmt)

-    var methodBindRegsitry = initSet[string]()
+    var methodBindRegsitry = initHashSet[string]()
    let obj = typ.jsonNode
    if typ.baseName != "NimGodotObject":
      let baseModule = typeNameToModuleName(typ.baseName)
@ -1012,7 +1082,6 @@ when isMainModule:
  import os

  const usage = """Tool for wrapping Godot API into Nim
-
    godotapigen [godot binary path] [target directory]"""

  proc main() =
--- a/godot/godotinternal.nim
+++ b/godot/godotinternal.nim
@ -1,8 +1,8 @@
 # Copyright 2018 Xored Software, Inc.

-import internal.godotinternaltypes, internal.godotarrays,
-       internal.godotnodepaths, internal.godotpoolarrays, internal.godotstrings,
-       internal.godotvariants, internal.godotdictionaries
+import internal/godotinternaltypes, internal/godotarrays,
+       internal/godotnodepaths, internal/godotpoolarrays, internal/godotstrings,
+       internal/godotvariants, internal/godotdictionaries

 import gdnativeapi
 export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays,
@ -93,6 +93,11 @@ proc getClassName*(o: ptr GodotObject): string =
    # There are physics type not known by ClassDB
    result = result[0..result.len-3]

+proc getClassNameRaw*(o: ptr GodotObject): GodotString =
+  if getClassMethodBind.isNil:
+    getClassMethodBind = getMethod(cstring"Object", cstring"get_class")
+  getClassMethodBind.ptrCall(o, nil, addr result)
+
 proc getGodotSingleton*(name: cstring): ptr GodotObject {.inline.} =
  getGDNativeAPI().globalGetSingleton(name)

--- a/godot/internal/backwardcompat.inc.nim
+++ b/godot/internal/backwardcompat.inc.nim
@ -0,0 +1,19 @@
+# Copyright 2019 Xored Software, Inc.
+
+when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
+  import macros, sets
+
+  proc strVal(n: NimNode): string {.used.} =
+    case n.kind
+    of nnkIdent:
+      $n.ident
+    of nnkSym:
+      $n.symbol
+    else:
+      macros.strVal(n)
+
+  proc toHashSet[A](keys: openArray[A]): HashSet[A] {.inline, used.} =
+    toSet(keys)
+
+  proc initHashSet[A](): HashSet[A] {.inline, used.} =
+    initSet[A]()
--- a/godot/internal/godotarrays.nim
+++ b/godot/internal/godotarrays.nim
@ -1,6 +1,6 @@
 # Copyright (c) 2018 Xored Software, Inc.

-import godotinternaltypes, gdnativeapi, core.godotcoretypes
+import godotinternaltypes, gdnativeapi, core/godotcoretypes

 proc len*(self: GodotArray): cint {.inline.} =
  getGDNativeAPI().arraySize(self)
--- a/godot/internal/godotinternaltypes.nim
+++ b/godot/internal/godotinternaltypes.nim
@ -66,6 +66,8 @@ type
  GodotString* {.byref.} = object
    data: array[sizeof(int), byte]

+  cwchar_t* {.importc: "wchar_t", nodecl.} = object
+
  GodotCharString* {.byref.} = object
    data: array[sizeof(int), byte]

@ -114,7 +116,8 @@ type
    expected*: VariantType

  GodotVariant* {.byref.} = object
-    data: array[4 + sizeof(int) div 4, float32]
+    data: array[2, int64]
+    data2: int

 type GodotMethodBind* = object

@ -305,3 +308,6 @@ type

  GodotClassConstructor* = proc (): ptr GodotObject {.
    noconv, gcsafe, locks: 0, raises: [], tags: [].}
+
+template offset*[T](p: ptr T, offset: int): ptr T =
+  cast[ptr T](cast[ByteAddress](p) +% (offset * sizeof(T)))
--- a/godot/internal/godotpoolarrays.nim
+++ b/godot/internal/godotpoolarrays.nim
@ -1,10 +1,7 @@
 # Copyright (c) 2018 Xored Software, Inc.

 import godotinternaltypes, gdnativeapi
-import core.godotcoretypes
-
-proc offset[T](p: ptr T, offset: int): ptr T {.inline.} =
-  cast[ptr T](cast[ByteAddress](p) +% (offset * sizeof(T)))
+import core/godotcoretypes

 template genPoolArrayAPI(ArrayT, initIdent, DataT,
                         newProc, newCopyProc, newWithArrayProc, appendProc,
@ -48,7 +45,15 @@ template genPoolArrayAPI(ArrayT, initIdent, DataT,
    getGDNativeAPI().setProc(self, idx, data)

  proc `[]`*(self: ArrayT; idx: cint): DataT {.inline.} =
-    getGDNativeAPI().getProc(self, idx)
+    let data = getGDNativeAPI().getProc(self, idx)
+    when DataT is Color:
+      data.toColor()
+    elif DataT is Vector2:
+      data.toVector2()
+    elif DataT is Vector3:
+      data.toVector3()
+    else:
+      data

  proc len*(self: ArrayT): cint {.inline.} =
    getGDNativeAPI().sizeProc(self)
--- a/godot/internal/godotstrings.nim
+++ b/godot/internal/godotstrings.nim
@ -22,6 +22,12 @@ proc `&`*(self, b: GodotString): GodotString {.inline.} =
 proc deinit*(self: var GodotString) {.inline.} =
  getGDNativeAPI().stringDestroy(self)

+proc len*(self: GodotString): cint {.inline.} =
+  getGDNativeAPI().stringLength(self)
+
+proc dataPtr*(self: GodotString): ptr cwchar_t {.inline.} =
+  getGDNativeAPI().stringWideStr(self)
+
 proc `$`*(self: GodotString): string =
  ## Converts the ``GodotString`` into Nim string
  var charStr = getGDNativeAPI().stringUtf8(self)
@ -32,10 +38,13 @@ proc `$`*(self: GodotString): string =

 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``
--- a/godot/internal/godotvariants.nim
+++ b/godot/internal/godotvariants.nim
@ -1,6 +1,6 @@
 # Copyright 2018 Xored Software, Inc.

-import core.godotcoretypes, godotinternaltypes, gdnativeapi
+import core/godotcoretypes, godotinternaltypes, gdnativeapi

 proc getType*(p: GodotVariant): VariantType {.inline.} =
  getGDNativeAPI().variantGetType(p)
@ -121,34 +121,34 @@ proc asGodotString*(self: GodotVariant): GodotString {.inline.} =
  getGDNativeAPI().variantAsString(self)

 proc asVector2*(self: GodotVariant): Vector2 {.inline.} =
-  getGDNativeAPI().variantAsVector2(self)
+  getGDNativeAPI().variantAsVector2(self).toVector2()

 proc asRect2*(self: GodotVariant): Rect2 {.inline.} =
-  getGDNativeAPI().variantAsRect2(self)
+  getGDNativeAPI().variantAsRect2(self).toRect2()

 proc asVector3*(self: GodotVariant): Vector3 {.inline.} =
-  getGDNativeAPI().variantAsVector3(self)
+  getGDNativeAPI().variantAsVector3(self).toVector3()

 proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} =
-  getGDNativeAPI().variantAsTransform2D(self)
+  getGDNativeAPI().variantAsTransform2D(self).toTransform2D()

 proc asPlane*(self: GodotVariant): Plane {.inline.} =
-  getGDNativeAPI().variantAsPlane(self)
+  getGDNativeAPI().variantAsPlane(self).toPlane()

 proc asQuat*(self: GodotVariant): Quat {.inline.} =
-  getGDNativeAPI().variantAsQuat(self)
+  getGDNativeAPI().variantAsQuat(self).toQuat()

 proc asAABB*(self: GodotVariant): AABB {.inline.} =
-  getGDNativeAPI().variantAsAABB(self)
+  getGDNativeAPI().variantAsAABB(self).toAABB()

 proc asBasis*(self: GodotVariant): Basis {.inline.} =
-  getGDNativeAPI().variantAsBasis(self)
+  getGDNativeAPI().variantAsBasis(self).toBasis()

 proc asTransform*(self: GodotVariant): Transform {.inline.} =
-  getGDNativeAPI().variantAsTransform(self)
+  getGDNativeAPI().variantAsTransform(self).toTransform()

 proc asColor*(self: GodotVariant): Color {.inline.} =
-  getGDNativeAPI().variantAsColor(self)
+  getGDNativeAPI().variantAsColor(self).toColor()

 proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} =
  getGDNativeAPI().variantAsNodePath(self)
--- a/godot/nim/godotmacros.nim
+++ b/godot/nim/godotmacros.nim
@ -1,8 +1,8 @@
 # Copyright 2018 Xored Software, Inc.

-import macros, tables, typetraits
-import godotinternal, internal.godotvariants
-import godotnim, core.variants
+import macros, tables, typetraits, strutils, sets, sequtils, options, algorithm
+import godotinternal, internal/godotvariants
+import godotnim, core/variants

 type
  VarDecl = ref object
@ -10,8 +10,8 @@ type
    typ: NimNode
    defaultValue: NimNode
    isNoGodot: bool
-    hint: string
-    hintStr: string
+    hint: Option[string]
+    hintStr: Option[string]
    usage: NimNode
    isExported: bool

@ -32,6 +32,8 @@ type

  ParseError = object of Exception

+include "internal/backwardcompat.inc.nim"
+
 proc godotToNim[T](val: Variant): (T, ConversionResult) =
  mixin fromVariant
  result[1] = fromVariant(result[0], val)
@ -51,15 +53,15 @@ template parseError(node: NimNode, msg: string) =
 proc extractNames(definition: NimNode):
    tuple[name, parentName: string] =
  if definition.kind == nnkIdent:
-    result.name = $(definition.ident)
+    result.name = definition.strVal
  else:
    if not (definition.kind == nnkInfix and
-            definition[0].ident == toNimIdent("of")):
+            definition[0].strVal == "of"):
      parseError(definition, "invalid type definition")
-    result.name = $(definition[1].ident)
+    result.name = definition[1].strVal
    case definition[2].kind:
      of nnkIdent:
-        result.parentName = $definition[2].ident
+        result.parentName = definition[2].strVal
      else:
        parseError(definition[2], "parent type expected")

@ -72,13 +74,13 @@ proc newCStringLit(s: string): NimNode {.compileTime.} =
  newNimNode(nnkCallStrLit).add(ident("cstring"), newRStrLit(s))

 iterator pragmas(node: NimNode):
-      tuple[key: NimIdent, value: NimNode, index: int] =
+      tuple[key: string, value: NimNode, index: int] =
  assert node.kind in {nnkPragma, nnkEmpty}
  for index in countdown(node.len - 1, 0):
    if node[index].kind == nnkExprColonExpr:
-      yield (node[index][0].ident, node[index][1], index)
+      yield (node[index][0].strVal, node[index][1], index)
    elif node[index].kind == nnkIdent:
-      yield (node[index].ident, nil, index)
+      yield (node[index].strVal, nil, index)

 proc removePragmaNode(statement: NimNode,
                      pname: string): NimNode {.compileTime.} =
@ -91,9 +93,8 @@ proc removePragmaNode(statement: NimNode,
  result = nil
  var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma()
                else: statement[1]
-  let pnameIdent = toNimIdent(pname)
  for ident, val, i in pragmas(pragmas):
-    if ident == pnameIdent:
+    if ident.eqIdent(pname):
      pragmas.del(i)
      return val

@ -104,19 +105,18 @@ proc removePragma(statement: NimNode, pname: string): bool =
    return false
  var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma()
                else: statement[1]
-  let pnameIdent = toNimIdent(pname)
  for ident, val, i in pragmas(pragmas):
-    if ident == pnameIdent:
+    if ident.eqIdent(pname):
      pragmas.del(i)
      return true

 proc removeStrPragma(statement: NimNode,
-                     pname: string): string {.compileTime.} =
+                     pname: string): Option[string] {.compileTime.} =
  ## Removes the pragma from the node and returns value of the pragma
  ## Works for routine nodes or nnkPragmaExpr
  let node = removePragmaNode(statement, pname)
-  result = if node.isNil: nil
-           else: $node
+  result = if node.isNil: none(string)
+           else: some($node)

 proc isExported(node: NimNode): bool {.compileTime.} =
  if node.kind == nnkPragmaExpr:
@ -172,10 +172,15 @@ proc parseMethod(meth: NimNode): MethodDecl =

 proc parseVarSection(decl: NimNode): seq[VarDecl] =
  assert(decl.kind == nnkVarSection)
-  result = identDefsToVarDecls(decl[0])
+  for i in 0..<decl.len:
+    if i == 0:
+      result = identDefsToVarDecls(decl[i])
+    else:
+      result.add(identDefsToVarDecls(decl[i]))

-proc parseType(definition, callSite: NimNode): ObjectDecl =
-  let body = callSite[^1]
+proc parseType(ast: NimNode): ObjectDecl =
+  let definition = ast[0]
+  let body = ast[^1]
  result = ObjectDecl(
    fields: newSeq[VarDecl](),
    methods: newSeq[MethodDecl]()
@ -183,17 +188,17 @@ proc parseType(definition, callSite: NimNode): ObjectDecl =
  (result.name, result.parentName) = extractNames(definition)

  var isTool = false
-  for i in 2..(callSite.len - 2):
-    let option = callSite[i]
+  for i in 1..(ast.len - 2):
+    let option = ast[i]
    if option.kind != nnkIdent:
      parseError(option, "type specifier expected")
-    if option.ident == toNimIdent("tool"):
+    if option.strVal == "tool":
      isTool = true
    else:
      parseError(option, "valid type specifier expected")
  result.isTool = isTool

-  if result.parentName.isNil: result.parentName = "Object"
+  if result.parentName.len == 0: result.parentName = "Object"
  for statement in body:
    case statement.kind:
      of nnkVarSection:
@ -210,7 +215,7 @@ proc parseType(definition, callSite: NimNode): ObjectDecl =
 macro invokeVarArgs(procIdent, objIdent;
                    minArgs, maxArgs: static[int], numArgsIdent,
                    argSeqIdent; argTypes: seq[NimNode],
-                    hasReturnValue, isStaticCall: static[bool]): typed =
+                    hasReturnValue, isStaticCall: static[bool]): untyped =
  ## Produces statement in form:
  ##
  ## .. code-block:: nim
@ -267,8 +272,12 @@ macro invokeVarArgs(procIdent, objIdent;
      invocation = newNimNode(nnkCall).add(ident("procCall"), invocation)

    if hasReturnValue:
+      let resultVariant = genSym(nskLet, "ret")
+      branchBody.add(
+        newNimNode(nnkLetSection).add(
+          newIdentDefs(resultVariant, ident("Variant"), newCall("toVariant", invocation))))
      let theCall = newNimNode(nnkBracketExpr).add(newNimNode(nnkDotExpr).add(
-        newCall("toVariant", invocation), ident("godotVariant")))
+        resultVariant, ident("godotVariant")))
      branchBody.add(getAst(initGodotVariantCall(ident("result"), theCall)))
    else:
      branchBody.add(invocation)
@ -283,7 +292,7 @@ macro invokeVarArgs(procIdent, objIdent;
      " arguments, but got " & $numArgs)

  result.add(newNimNode(nnkElse).add(getAst(
-    printInvokeErr($procIdent.ident, minArgs, maxArgs, numArgsIdent))))
+    printInvokeErr(procIdent.strVal, minArgs, maxArgs, numArgsIdent))))

 proc typeError(nimType: string, value: string, godotType: VariantType,
               className: cstring, propertyName: cstring): string =
@ -391,10 +400,9 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit,
    getFunc: getFuncIdent
  )
  mixin godotTypeInfo
-  static:
-    var typeInfo: GodotTypeInfo
-    when compiles(godotTypeInfo(propTypeIdent)):
-      typeInfo = godotTypeInfo(propTypeIdent)
+  const typeInfo = when compiles(godotTypeInfo(propTypeIdent)):
+                    godotTypeInfo(propTypeIdent)
+                   else: GodotTypeInfo()
  const hintStr = when hintStrLit != "NIM":
                    hintStrLit
                  else:
@ -420,9 +428,6 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit,
                               unsafeAddr attr, setFunc, getFunc)
  hintStrGodot.deinit()

-static:
-  import strutils, sets, sequtils
-
 proc toGodotStyle(s: string): string {.compileTime.} =
  result = newStringOfCap(s.len + 10)
  for c in s:
@ -443,7 +448,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
  let objTy = newNimNode(nnkObjectTy)
  typeDef.add(newNimNode(nnkRefTy).add(objTy))
  objTy.add(newEmptyNode())
-  if obj.parentName.isNil:
+  if obj.parentName.len == 0:
    objTy.add(newEmptyNode())
  else:
    objTy.add(newNimNode(nnkOfInherit).add(ident(obj.parentName)))
@ -453,7 +458,8 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
  let initBody = newStmtList()
  for decl in obj.fields:
    if not decl.defaultValue.isNil and decl.defaultValue.kind != nnkEmpty:
-      initBody.add(newNimNode(nnkAsgn).add(decl.name, decl.defaultValue))
+      initBody.add(newNimNode(nnkAsgn).add(newDotExpr(ident("self"), decl.name),
+          decl.defaultValue))
    let name = if not decl.isExported: decl.name
               else: postfix(decl.name, "*")
    recList.add(newIdentDefs(name, decl.typ))
@ -479,6 +485,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
  else:
    initMethod.body.insert(0, initBody)

+  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
    # {.this: self.} for convenience
    result.add(newNimNode(nnkPragma).add(newNimNode(nnkExprColonExpr).add(
      ident("this"), ident("self")
@ -502,23 +509,25 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
    result.add(meth.nimNode)

  # Register Godot object
-  let parentName = if obj.parentName.isNil: newStrLitNode("Object")
+  let parentName = if obj.parentName.len == 0: newStrLitNode("Object")
                   else: newStrLitNode(obj.parentName)
-  let classNameLit = newCStringLit(obj.name)
+  let classNameLit = newStrLitNode(obj.name)
  let classNameIdent = ident(obj.name)
-  let isRef: bool = if obj.parentName.isNil: false
+  let isRef: bool = if obj.parentName.len == 0: false
                    else: obj.parentName in refClasses
+  # Wrapping bools with a newLit is required as a temporary workaround for
+  # https://github.com/nim-lang/Nim/issues/7375
  result.add(getAst(
-    registerGodotClass(classNameIdent, classNameLit, isRef, parentName,
-                       genSym(nskProc, "createFunc"), obj.isTool)))
+    registerGodotClass(classNameIdent, classNameLit, newLit(isRef), parentName,
+                       genSym(nskProc, "createFunc"), newLit(obj.isTool))))

  # Register fields (properties)
  for field in obj.fields:
    if field.isNoGodot: continue
-    let hintStr = if field.hintStr.isNil: "NIM"
-                  else: field.hintStr
-    let hint = if field.hint.isNil: "NIM"
-               else: field.hint
+    let hintStr = if field.hintStr.isNone: "NIM"
+                  else: field.hintStr.get
+    let hint = if field.hint.isNone: "NIM"
+               else: field.hint.get
    let usage =
      if field.usage.isNil:
        newLit(ord(GodotPropertyUsage.Default) or
@ -541,17 +550,23 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
  template registerGodotMethod(classNameLit, classNameIdent, methodNameIdent,
                               methodNameLit, minArgs, maxArgs,
                               argTypes, methFuncIdent, hasReturnValue) =
+    when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
      {.emit: """/*TYPESECTION*/
 N_NOINLINE(void, setStackBottom)(void* thestackbottom);
 """.}
+
    proc methFuncIdent(obj: ptr GodotObject, methodData: pointer,
                       userData: pointer, numArgs: cint,
                       args: var array[MAX_ARG_COUNT, ptr GodotVariant]):
                      GodotVariant {.noconv.} =
      var stackBottom {.volatile.}: pointer
+      stackBottom = addr(stackBottom)
+      when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
        {.emit: """
          setStackBottom((void*)(&`stackBottom`));
        """.}
+      else:
+        nimGC_setStackBottom(stackBottom)
      let self = cast[classNameIdent](userData)
      const isStaticCall = methodNameLit == cstring"_ready" or
                           methodNameLit == cstring"_process" or
@ -595,7 +610,7 @@ N_NOINLINE(void, setStackBottom)(void* thestackbottom);
    let hasReturnValueBool = not (meth.returnType.isNil or
                         meth.returnType.kind == nnkEmpty or
                          (meth.returnType.kind == nnkIdent and
-                          meth.returnType.ident == toNimIdent("void")))
+                          meth.returnType.strVal == "void"))
    let hasReturnValue = if hasReturnValueBool: ident("true")
                         else: ident("false")
    result.add(getAst(
@ -621,11 +636,7 @@ N_NOINLINE(void, setStackBottom)(void* thestackbottom);
                                 GodotMethodAttributes(), refDec)
    result.add(getAst(registerRefIncDec(classNameLit)))

-{.push warning[Deprecated]: off.}
-# immediate macros are deprecated, but `untyped` doesn't make it immediate,
-# as the warning and the documentation claim.
-
-macro gdobj*(definition: untyped, body: typed): typed {.immediate.} =
+macro gdobj*(ast: varargs[untyped]): untyped =
  ## Generates Godot type. Self-documenting example:
  ##
  ## .. code-block:: nim
@ -633,7 +644,7 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} =
  ##
  ##   gdobj MyObj of Node:
  ##     var myField: int
-  ##       ## Not exported to Godot (i.e. editor will not see this field).
+  ##       ## Not exported to Godot (i.e. editor and scripts will not see this field).
  ##
  ##     var myString* {.gdExport, hint: Length, hintStr: "20".}: string
  ##       ## Exported to Godot as ``my_string``.
@ -646,12 +657,12 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} =
  ##       ## Exported methods are exported to Godot by default,
  ##       ## and their Godot names are prefixed with ``_``
  ##       ## (in this case ``_ready``)
-  ##       print("I am ready! myString is: " & myString)
+  ##       print("I am ready! myString is: " & self.myString)
  ##
  ##     proc myProc*() {.gdExport.} =
  ##       ## Exported to Godot as ``my_proc``
  ##       print("myProc is called! Incrementing myField.")
-  ##       inc myField
+  ##       inc self.myField
  ##
  ## If parent type is omitted, the type is inherited from ``Object``.
  ##
@ -669,7 +680,5 @@ macro gdobj*(definition: untyped, body: typed): typed {.immediate.} =
  ## `gdnew <godotnim.html#gdnew>`_ or by using
  ## `load <godotapi/resource_loader.html#load,string,string,bool>`_ or any other way
  ## that you can find in `Godot API <index.html#modules-godot-api>`_.
-  let typeDef = parseType(definition, callsite())
+  let typeDef = parseType(ast)
  result = genType(typeDef)
-
-{.push warning[Deprecated]: on.}
--- a/godot/nim/godotnim.nim
+++ b/godot/nim/godotnim.nim
@ -1,14 +1,14 @@
 # Copyright 2018 Xored Software, Inc.

-import tables, typetraits, macros
+import tables, typetraits, macros, unicode, strutils, sets, options
 import gdnativeapi
-import core.godotcoretypes, core.godotbase
-import core.vector2, core.rect2,
-       core.vector3, core.transform2d,
-       core.planes, core.quats, core.aabb,
-       core.basis, core.transforms, core.colors,
-       core.nodepaths, core.rids, core.dictionaries,
-       core.arrays, core.poolarrays, core.variants
+import core/godotcoretypes, core/godotbase
+import core/vector2, core/rect2,
+       core/vector3, core/transform2d,
+       core/planes, core/quats, core/aabb,
+       core/basis, core/transforms, core/colors,
+       core/nodepaths, core/rids, core/dictionaries,
+       core/arrays, core/poolarrays, core/variants
 import godotinternal

 ## This module defines ``NimGodotObject`` and ``toVariant``/``fromVariant``
@ -31,7 +31,7 @@ type
    ## The base type all Godot types inherit from.
    ## Manages lifecycle of the wrapped ``GodotObject``.
    godotObject: ptr GodotObject
-    linkedObject: NimGodotObject
+    linkedObjectPtr: pointer
      ## Wrapper around native object that is the container of the Nim "script"
      ## This is needed for `of` checks and `as` conversions to work as
      ## expected. For example, Nim type may inherit from ``Spatial``, but the
@ -39,6 +39,8 @@ type
      ## ``Particles`` is valid, but Nim type system is not aware of that.
      ## This works in both directions - for linked native object this
      ## reference points to Nim object.
+      ## This is stored as a raw pointer to avoid reference cycles and therefore
+      ## improve GC performance.
    isRef*: bool
    isFinalized: bool
    isNative: bool
@ -89,21 +91,71 @@ type
      ## values.
      ## See documentation of ``GodotPropertyHint`` for description of formats.

+  FNV1Hash = uint32
+
+include "internal/backwardcompat.inc.nim"
+
 proc isFinalized*(obj: NimGodotObject): bool {.inline.} =
  obj.isFinalized

-var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo]
-var classRegistryStatic* {.compileTime.}: TableRef[cstring, ObjectInfo]
+var classRegistry {.threadvar.}: TableRef[FNV1Hash, ObjectInfo]
+var classRegistryStatic* {.compileTime.}: TableRef[FNV1Hash, ObjectInfo]
  ## Compile-time variable used for implementation of several procedures
  ## and macros
 static:
-  classRegistryStatic = newTable[cstring, ObjectInfo]()
+  classRegistryStatic = newTable[FNV1Hash, ObjectInfo]()

-static:
-  import sets, strutils
 var nativeClasses {.compileTime.} = newSeq[string]()
 var refClasses* {.compileTime.} = newSeq[string]()

+template initFNV1Hash(hash: var FNV1Hash) =
+  hash = 0x811c9dc5'u32
+
+template appendFNV1Hash(hash: var FNV1Hash, val: uint8) =
+  block:
+    let u64hash = hash.uint64
+    hash = ((
+      u64hash +
+      (u64hash shl 1'u64) +
+      (u64hash shl 4'u64) +
+      (u64hash shl 7'u64) +
+      (u64hash shl 8'u64) +
+      (u64hash shl 24'u64)) and 0xFFFFFFFF'u32).uint32 xor val
+
+{.push stackTrace:off.}
+proc lsb(c: ptr cwchar_t): char {.noinit, inline.} =
+  {.emit: [result, " = (char)(", c[]," & 0xFF);"]}
+{.pop.}
+
+proc fnv1Hash(godotClassName: GodotString): FNV1Hash =
+  var charsCount = godotClassName.len
+  let charsPtr = godotClassName.dataPtr
+  if charsCount > 2 and
+     charsPtr.offset(charsCount - 2).lsb == 'S' and
+     charsPtr.offset(charsCount - 1).lsb == 'W':
+    charsCount -= 2
+
+  initFNV1Hash(result)
+  for i in 0..<charsCount:
+    let c = charsPtr.offset(i).lsb
+    appendFNV1Hash(result, c.uint8)
+
+proc fnv1Hash(godotClassName: string): FNV1Hash {.compileTime.} =
+  var charsCount = godotClassName.len
+  if godotClassName.endsWith("SW"):
+    charsCount -= 2
+
+  initFNV1Hash(result)
+  var i = 0
+  for rune in runes(godotClassName):
+    if i >= charsCount:
+      break
+    let firstByte = uint8(rune.uint64 and 0xFF'u64)
+    appendFNV1Hash(result, firstByte)
+    # We don't really need to calculate hash of other bytes,
+    # since we only use hashes of ASCII strings
+    inc i
+
 proc getClassName*(o: NimGodotObject): string =
  o.godotObject.getClassName()

@ -135,12 +187,15 @@ proc deinit*(obj: NimGodotObject) =
  obj.godotObject.deinit()
  obj.godotObject = nil

+proc linkedObject(obj: NimGodotObject): NimGodotObject {.inline.} =
+  cast[NimGodotObject](obj.linkedObjectPtr)
+
 proc nimGodotObjectFinalizer*[T: NimGodotObject](obj: T) =
  if obj.godotObject.isNil or obj.isNative: return
  # important to set it before so that ``unreference`` is aware
  obj.isFinalized = true
-  if obj.isRef and obj.godotObject.unreference() or
-     not obj.linkedObject.isNil:
+  if (obj.isRef or not obj.linkedObject.isNil and obj.linkedObject.isRef) and
+     obj.godotObject.unreference():
    obj.deinit()

 macro baseNativeType(T: typedesc): cstring =
@ -154,7 +209,7 @@ macro baseNativeType(T: typedesc): cstring =
    if typeName == "NimGodotObject":
      break
    t = getType(t[1][1])
-  if baseT.isNil:
+  if baseT.len == 0:
    result = newNilLit()
  else:
    let rStr = newNimNode(nnkRStrLit)
@ -179,12 +234,12 @@ macro isResource(T: typedesc): bool =
  result = if inherits(getType(T), "Resource"): ident("true")
           else: ident("false")

-template registerClass*(T: typedesc; godotClassName: cstring,
+template registerClass*(T: typedesc; godotClassName: string or cstring,
                        native: bool) =
  ## Registers the specified Godot type.
  ## Used by ``gdobj`` macro and `godotapigen <godotapigen.html>`_.
  if classRegistry.isNil:
-    classRegistry = newTable[cstring, ObjectInfo]()
+    classRegistry = newTable[FNV1Hash, ObjectInfo]()
  let constructor = proc(): NimGodotObject =
    var t: T
    new(t, nimGodotObjectFinalizer[T])
@ -198,14 +253,22 @@ template registerClass*(T: typedesc; godotClassName: cstring,
    isNative: native,
    isRef: isRef
  )
-  classRegistry[godotClassName] = objInfo
+  classRegistry[fnv1Hash($godotClassName)] = objInfo
  static:
    let objInfoStatic = ObjectInfo(
      baseNativeClass: base,
      isNative: native,
      isRef: isRef,
    )
-    classRegistryStatic[godotClassName] = objInfoStatic
+    let nameHash = fnv1Hash($godotClassName)
+    if not classRegistryStatic.contains(nameHash):
+      classRegistryStatic[nameHash] = objInfoStatic
+    elif not endsWith($godotClassName, "SW"):
+      # For simplicity we assume that all class names must have
+      # different hashes
+      # If this exception is ever raised, I guess, we should
+      # implement a proper collision resolving
+      raise newException(Exception, "Hash collision " & $godotClassName)
  when isRef:
    static:
      refClasses.add(T.name)
@ -214,10 +277,10 @@ template registerClass*(T: typedesc; godotClassName: cstring,
      nativeClasses.add(T.name)

 proc newNimGodotObject[T: NimGodotObject](
-    godotObject: ptr GodotObject, godotClassName: cstring, noRef: bool): T =
+    godotObject: ptr GodotObject, godotClassName: GodotString, noRef: bool): T =
  assert(not classRegistry.isNil)
  assert(not godotObject.isNil)
-  let objInfo = classRegistry.getOrDefault(godotClassName)
+  let objInfo = classRegistry.getOrDefault(fnv1Hash(godotClassName))
  if objInfo.constructor.isNil:
    printError("Nim constructor not found for class " & $godotClassName)
  else:
@ -240,9 +303,11 @@ proc asNimGodotObject*[T: NimGodotObject](
      # Could be data from other bindings
      result = nil
  if result.isNil:
+    var classNameStr = godotObject.getClassNameRaw()
    result = newNimGodotObject[T](
-      godotObject, cstring(godotObject.getClassName()),
+      godotObject, classNameStr,
      forceNativeObject or noRef)
+    deinit(classNameStr)

 proc newVariant*(obj: NimGodotObject): Variant {.inline.} =
  newVariant(obj.godotObject)
@ -272,9 +337,6 @@ proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T =
  elif not obj.linkedObject.isNil and system.`of`(obj.linkedObject, T):
    result = T(obj.linkedObject)
  else:
-    when not defined(release):
-      printError("Failed to cast object to " &
-                  T.name & "\n" & getStackTrace())
    result = nil

 proc `of`*[T1, T2: NimGodotObject](obj: T1, t: typedesc[T2]): bool {.inline.} =
@ -285,26 +347,20 @@ proc newRStrLit(s: string): NimNode {.compileTime.} =
  result = newNimNode(nnkRStrLit)
  result.strVal = s

-static:
-  import strutils
-
-macro toGodotName(T: typedesc): string =
-  var godotName: string
+macro toGodotName(T: typedesc): untyped =
  if T is GodotString or T is string:
-    godotName = "String"
+    newStrLitNode"String"
  elif T is SomeFloat:
-    godotName = "float"
+    newStrLitNode"float"
  elif T is SomeUnsignedInt or T is SomeSignedInt:
-    godotName = "int"
-  if godotName.isNil or godotName.len == 0:
-    let nameStr = (($T.getType()[1][1].symbol).split(':')[0])
-    godotName = case nameStr:
-    of "File", "Directory", "Thread", "Mutex", "Semaphore":
-      "_" & nameStr
+    newStrLitNode"int"
  else:
-      nameStr
-
-  result = newLit(godotName)
+    let nameStr = ((T.getType()[1][1].strVal).split(':')[0])
+    case nameStr:
+      of "File", "Directory", "Thread", "Mutex", "Semaphore":
+        newStrLitNode("_" & nameStr)
+      else:
+        newStrLitNode(nameStr)

 macro asCString(s: static[string]): cstring =
  result = newNimNode(nnkCallStrLit).add(
@ -363,17 +419,18 @@ proc newOwnObj[T: NimGodotObject](name: cstring): T =

 proc gdnew*[T: NimGodotObject](): T =
  ## Instantiates new object of type ``T``.
-  const godotName = asCString(toGodotName(T))
-  const objInfo = classRegistryStatic[godotName]
+  const godotName = toGodotName(T)
+  const cGodotName = asCString(godotName)
+  const objInfo = classRegistryStatic[fnv1Hash(godotName)]
  when objInfo.isNative:
-    let godotObject = getClassConstructor(godotName)()
+    let godotObject = getClassConstructor(cGodotName)()
    new(result, nimGodotObjectFinalizer[T])
    result.godotObject = godotObject
    when objInfo.isRef:
      godotObject.initRef()
      result.isRef = true
  else:
-    result = newOwnObj[T](godotName)
+    result = newOwnObj[T](cGodotName)

 proc newCallError*(err: VariantCallError): ref CallError =
  ## Instantiates ``CallError`` from Godot ``err``.
@ -413,14 +470,17 @@ proc setGodotObject*(nimObj: NimGodotObject, obj: ptr GodotObject) {.inline.} =
 proc setNativeObject*(nimObj: NimGodotObject,
                      nativeObj: NimGodotObject) {.inline.} =
  ## Used from Godot constructor produced by ``gdobj`` macro. Do not call.
-  nimObj.linkedObject = nativeObj
-  nativeObj.linkedObject = nimObj
+  GC_ref(nativeObj)
+  nimObj.linkedObjectPtr = cast[pointer](nativeObj)
+  nativeObj.linkedObjectPtr = cast[pointer](nimObj)
  nativeObj.isNative = true

 proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} =
  ## Used from Godot destructor produced by ``gdobj`` macro. Do not call.
+  GC_unref(nimObj.linkedObject)
  nimObj.godotObject = nil
  nimObj.linkedObject.godotObject = nil
+  nimObj.linkedObjectPtr = nil

 proc `==`*(self, other: NimGodotObject): bool {.inline.} =
  ## Compares objects by referential equality.
@ -552,7 +612,11 @@ proc fromVariant*[T: SomeSignedInt or SomeUnsignedInt](
                 else: uint64)
    intVal = when T is SomeSignedInt: val.asInt()
             else: val.asUint()
-    if intVal > high(T) or intVal < low(T):
+    const highT = when T is SomeSignedInt: high(T).int64
+                  else: high(T).uint64
+    const lowT = when T is SomeSignedInt: low(T).int64
+                 else: low(T).uint64
+    if intVal > highT or intVal < lowT:
      result = ConversionResult.RangeError
    else:
      self = T(intVal)
@ -656,7 +720,10 @@ proc fromVariant*(s: var string, val: Variant): ConversionResult =
  if val.getType() == VariantType.String:
    s = val.asString()
  elif val.getType() == VariantType.Nil:
+    when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
      s = nil
+    else:
+      s = ""
  else:
    result = ConversionResult.TypeError

@ -730,10 +797,31 @@ proc fromVariant*[T: array](s: var T, val: Variant): ConversionResult =
  else:
    result = ConversionResult.TypeError

-proc godotTypeInfo*(T: typedesc[Table|TableRef]): GodotTypeInfo {.inline.} =
+proc godotTypeInfo*[T](OptT: typedesc[Option[T]]): GodotTypeInfo =
+  when compiles(godotTypeInfo(T)):
+    result.variantType = godotTypeInfo(T)
+  else:
+    result.variantType = VariantType.Nil
+
+proc toVariant*[T](option: Option[T]): Variant =
+  if option.isSome():
+    result = toVariant(option.unsafeGet())
+  else:
+    result = newVariant()
+
+proc fromVariant*[T](option: var Option[T], val: Variant): ConversionResult =
+  if val.getType() == VariantType.Nil:
+    option = none(T)
+  else:
+    var v: T
+    result = fromVariant(v, val)
+    if result == ConversionResult.OK:
+      option = some(result)
+
+proc godotTypeInfo*(T: typedesc[Table|TableRef|OrderedTable|OrderedTableRef]): GodotTypeInfo {.inline.} =
  result.variantType = VariantType.Dictionary

-proc toVariant*[T: Table or TableRef](t: T): Variant =
+proc toVariant*[T: Table or TableRef or OrderedTable or OrderedTableRef](t: T): Variant =
  when t is ref:
    if t.isNil:
      return newVariant()
@ -743,7 +831,7 @@ proc toVariant*[T: Table or TableRef](t: T): Variant =
    dict[toVariant(k)] = toVariant(v)
  result = newVariant(dict)

-proc fromVariant*[T: Table or TableRef](t: var T,
+proc fromVariant*[T: Table or TableRef or OrderedTable or OrderedTableRef](t: var T,
                                        val: Variant): ConversionResult =
  if val.getType() == VariantType.Nil:
    when t is ref:
@ -753,8 +841,12 @@ proc fromVariant*[T: Table or TableRef](t: var T,
    mixin fromVariant
    when t is Table:
      t = initTable[type(t.keys()), type(t.values())]()
-    else:
+    elif t is TableRef:
      t = newTable[type(t.keys()), type(t.values())]()
+    elif t is OrderedTable:
+      t = initOrderedTable[type(t.keys()), type(t.values())]()
+    else:
+      t = newOrderedTable[type(t.keys()), type(t.values())]()
    for k, v in dict:
      var nimKey: type(t.keys())
      var nimVal: type(t.values())
@ -772,6 +864,7 @@ proc fromVariant*[T: Table or TableRef](t: var T,
  else:
    result = ConversionResult.TypeError

+when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
  {.emit: """/*TYPESECTION*/
  N_LIB_EXPORT N_CDECL(void, NimMain)(void);
  N_NOINLINE(void, setStackBottom)(void* thestackbottom);
@ -788,10 +881,16 @@ proc godot_nativescript_init(handle: pointer) {.
  nativeLibHandle = handle

  var stackBottom {.volatile.}: pointer
+  stackBottom = addr(stackBottom)
  {.emit: """
    NimMain();
+  """.}
+  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
+    {.emit: """
      setStackBottom((void*)(&`stackBottom`));
    """.}
+  else:
+    nimGC_setStackBottom(stackBottom)
  GC_fullCollect()
  GC_disable()

@ -802,6 +901,7 @@ proc godot_gdnative_init(options: ptr GDNativeInitOptions) {.

 proc godot_gdnative_terminate(options: ptr GDNativeTerminateOptions) {.
    cdecl, exportc, dynlib.} =
+  if not options[].inEditor or not compileOption("threads"):
    deallocHeap(runFinalizers = not options[].inEditor, allowGcAfterwards = false)

 const nimGcStepLengthUs {.intdefine.} = 2000
@ -826,9 +926,13 @@ proc registerFrameCallback*(cb: proc () {.closure.}) =

 proc godot_nativescript_frame() {.cdecl, exportc, dynlib.} =
  var stackBottom {.volatile.}: pointer
+  stackBottom = addr(stackBottom)
+  when (NimMajor, NimMinor, NimPatch) < (0, 19, 0):
    {.emit: """
      setStackBottom((void*)(&`stackBottom`));
    """.}
+  else:
+    nimGC_setStackBottom(stackBottom)
  for cb in idleCallbacks:
    cb()
  GC_step(nimGcStepLengthUs, true, 0)
--- a/godot/nim/nim.cfg
+++ b/godot/nim/nim.cfg
@ -1 +1,2 @@
 --path:"$projectdir/../"
+-d:useRealtimeGc
Author	SHA1	Message	Date
Ruslan Mustakov	4175dbb3e5	Bump version to 0.8.2	2021-05-03 23:18:50 +07:00
Joey	7eadb07820	Move template below arrays import Fixes #81 Alternate workaround for https://github.com/nim-lang/Nim/issues/16462 without changing VariantType.	2021-05-03 23:17:18 +07:00
Jason	00d8ac2691	Support nim case insensitivy in pragmas	2021-03-12 11:09:55 +07:00
Arun Dilipan	388bea9205	Added moveToward for vectors.	2020-12-13 12:13:41 +07:00
ShalokShalom	f25c3c7a5d	Clarify version compability One guy in the chat just asked me, if this binding is for 3.0 only, or also for 3.2.3	2020-10-17 13:22:31 +07:00
Ruslan Mustakov	d3e5f91b40	Fix wrapping methods with Array return types	2020-08-14 01:44:48 +07:00
Ruslan Mustakov	3f46e3c648	Break reference cycle in NimGodotObject	2020-06-05 16:53:34 +07:00
Ruslan Mustakov	87707a86b4	Remove Travis badge from README Need to fix the CI script.	2020-06-03 18:06:18 +07:00
Ruslan Mustakov	031774f54f	More efficient and GC-safe conversions in API generator	2020-06-03 17:58:47 +07:00
Ruslan Mustakov	ed9ede5cb3	Up version to 0.7.27	2020-02-05 12:34:44 +07:00
Konstantin Zaitsev	a49fcbdac7	Fix variant size for 32bit platform with memory alignment	2020-02-05 11:36:42 +07:00
zetashift	157a90e4a0	add gensym in hygienic template fix thanks to demotohiro (#55 ) Add gensym in hygienic template fix thanks to demotohiro	2020-02-05 11:35:50 +07:00
Ruslan Mustakov	d1b82d351c	Fix unsigned int conversion to/from Variant	2019-12-23 20:53:13 +07:00
Ruslan Mustakov	78d3626fa3	Do not log error when casting fails This allows not to perform unnecessary 'of' check before casting, if cast failure is expected.	2019-12-04 23:58:13 +07:00
Ruslan Mustakov	1b8e7ccd98	Add variant conversion for Option[T]	2019-10-02 15:26:41 +07:00
Ruslan Mustakov	c2db807da4	Up version to 0.7.23	2019-09-20 09:20:50 +07:00
Dwana Games	7dd1b1ed5f	Add self to field initialization	2019-09-20 09:20:27 +07:00
Ruslan Mustakov	2f3f4034cf	Fix newVariant for nil strings and older Nim	2019-09-18 13:27:31 +07:00
Ruslan Mustakov	19b0c23d62	Finalize support for Nim 0.20 Closes #32, closes #41.	2019-09-15 20:11:15 +07:00
Dwana Games	0fecfdb3b8	Updated to work with nim 0.20 - Attempt to fix deprecated this:self pragma by injecting self to methods and properties (needs more testing) - Changed import headers to use / (slash) instead of . (period) - Fixed object branch in godotapigen.nim - Fixed deprecated nimNode.ident with nimNode.strVal Fix toGodotName function Consider procCall calls as special cases, otherwise it gives problems in _init function Fix infinite recursive call in Godot 3.2	2019-09-15 15:34:09 +07:00
zetashift	34fda99def	Small changes to add 0.18.0 compatibility Change toGodotName back to macro because that got fixed in devel change isSome to isNone in godotapigen	2019-09-15 15:33:59 +07:00
Fabian Keller	3a935b9308	attempt to make 0.19 compatible workaround for nim/macro/typedesc issue work-around for nim-lang/Nim#7375 fixed more isNil usages fixed new name of setStackBottom	2019-09-15 15:33:44 +07:00
Konstantin Zaitsev	f45281f5a0	Fix possible double free memory on exit	2019-09-12 18:59:11 +07:00
Ruslan Mustakov	db4bb91765	Fix editor crash in multithreaded mode	2019-07-09 13:48:54 +07:00
Ruslan Mustakov	e9d73d8ec4	Fix GDNative API procedure declarations Earlier signature mismatch caused problems on macOS with Godot 3.1.	2018-10-11 19:06:05 +07:00
Ruslan Mustakov	859f9f04fb	OrderedTable to Variant conversion support	2018-09-21 16:34:09 +07:00
Evgeny Zuev	ceaf66a34c	Make `classRegistry` use hashes instead of strings as keys for faster lookup Up version to 0.7.16	2018-08-29 13:44:37 +07:00
Ruslan Mustakov	fd5f77e7c2	Fix gdobj to properly handle var block	2018-08-14 17:59:24 +07:00