Rearrangements

godot.nimble

@@ -1,4 +1,4 @@
-version = "0.1.0"
+version = "0.1.1"
 author = "Xored Software, Inc."
 description = "Godot Engine bindings"
 license = "MIT"

godot/apigen/apigen.nim

@@ -822,6 +822,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) =
   genTypeFile(types, targetDir)
 
   writeFile(targetDir / "godotall.nim", megaImport)
+  writeFile(targetDir / splitPath(targetDir)[1] & ".nimble", "")
 
 when isMainModule:
   import os

godot/core/dictionary.nim

@@ -7,6 +7,16 @@ type
   Dictionary* {.importc: "godot_dictionary",
                 header: "godot_dictionary.h", byref.} = object
 
+proc initVariant(dest: var Variant; dict: Dictionary) {.
+    importc: "godot_variant_new_dictionary",
+    header: "godot_variant.h".}
+
+proc variant*(dict: Dictionary): Variant {.inline.} =
+  initVariant(result, dict)
+
+proc asDictionary*(self: Variant): Dictionary {.
+    importc: "godot_variant_as_dictionary", header: "godot_variant.h".}
+
 proc initDictionary(dest: var Dictionary;
                     src: Dictionary) {.
     importc: "godot_dictionary_new_copy",
@@ -52,6 +62,11 @@ proc values*(self: Dictionary): Array {.
     importc: "godot_dictionary_values", header: "godot_dictionary.h".}
 proc `[]`*(self: Dictionary; key: Variant): Variant {.
     importc: "godot_dictionary_get", header: "godot_dictionary.h".}
+
+proc `[]`*(self: Dictionary; keyStr: string): Variant =
+  let key = variant(keyStr)
+  result = self[key]
+
 proc `[]=`*(self: var Dictionary; key, value: Variant) {.
     importc: "godot_dictionary_set",
     header: "godot_dictionary.h".}

godot/core/godotcore.nim

@@ -28,14 +28,6 @@ proc call*(methodBind: ptr GodotMethodBind;
            callError: var VariantCallError): Variant {.
     importc: "godot_method_bind_call", header: "../godot.h".}
 
-var getClassMethodBind {.threadvar.}: ptr GodotMethodBind
-proc getClassName*(o: ptr GodotObject): string =
-  if getClassMethodBind.isNil:
-    getClassMethodBind = getMethod(cstring"Object", cstring"get_class")
-  var ret: GodotString
-  getClassMethodBind.ptrCall(o, nil, addr ret)
-  result = $ret
-
 # Script API
 
 type

godot/core/variant.nim

@@ -1,6 +1,6 @@
 import godotbase
 
-import arrays, basis, dictionary, nodepath
+import arrays, basis, nodepath
 import plane, poolarray, quat, rect2, rect3, rid
 import strings, transform, transform2d, vector2
 import vector3, color
@@ -100,9 +100,6 @@ proc initVariant(dest: var Variant; rid: RID) {.
     importc: "godot_variant_new_rid", header: "godot_variant.h".}
 proc initVariant(dest: var Variant; obj: ptr GodotObject) {.
     importc: "godot_variant_new_object", header: "godot_variant.h".}
-proc initVariant(dest: var Variant; dict: Dictionary) {.
-    importc: "godot_variant_new_dictionary",
-    header: "godot_variant.h".}
 proc initVariant(dest: var Variant; arr: Array) {.
     importc: "godot_variant_new_array", header: "godot_variant.h".}
 proc initVariant(dest: var Variant; pba: PoolByteArray) {.
@@ -146,7 +143,8 @@ proc variant*(s: GodotString): Variant {.inline.} =
   initVariant(result, s)
 
 proc variant*(s: string): Variant {.inline.} =
-  initVariant(result, s.toGodotString())
+  let godotStr = s.toGodotString()
+  initVariant(result, godotStr)
 
 proc variant*(v2: Vector2): Variant {.inline.} =
   initVariant(result, v2)
@@ -187,9 +185,6 @@ proc variant*(rid: RID): Variant {.inline.} =
 proc variant*(obj: ptr GodotObject): Variant {.inline.} =
   initVariant(result, obj)
 
-proc variant*(dict: Dictionary): Variant {.inline.} =
-  initVariant(result, dict)
-
 proc variant*(arr: Array): Variant {.inline.} =
   initVariant(result, arr)
 
@@ -255,8 +250,6 @@ proc asRid*(self: Variant): RID {.
     importc: "godot_variant_as_rid", header: "godot_variant.h".}
 proc asObject*(self: Variant): ptr GodotObject {.
     importc: "godot_variant_as_object", header: "godot_variant.h".}
-proc asDictionary*(self: Variant): Dictionary {.
-    importc: "godot_variant_as_dictionary", header: "godot_variant.h".}
 proc asArray*(self: Variant): Array {.
     importc: "godot_variant_as_array", header: "godot_variant.h".}
 proc asPoolByteArray*(self: Variant): PoolByteArray {.

godot/nim/godotnim.nim

@@ -51,6 +51,17 @@ static:
   import sets, strutils
 var nativeClasses {.compileTime.} = initSet[string]()
 
+var getClassMethodBind {.threadvar.}: ptr GodotMethodBind
+proc getClassName*(o: ptr GodotObject): string =
+  if getClassMethodBind.isNil:
+    getClassMethodBind = getMethod(cstring"Object", cstring"get_class")
+  var ret: GodotString
+  getClassMethodBind.ptrCall(o, nil, addr ret)
+  result = $ret
+  if result.endsWith("SW"):
+    # There are physics type not known by ClassDB
+    result = result[0..result.len-3]
+
 proc godotFinalizer[T: NimGodotObject](obj: T) =
   # hmm, not sure yet how to deal with references correctly
   # when T is Reference: