jyapayne/godot-nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

No destructors

Browse source
This commit is contained in:
Ruslan Mustakov 2017-07-28 00:28:17 +07:00
commit f5769045fc
34 changed files with 1701 additions and 1216 deletions
Download patch file Download diff file Expand all files Collapse all files

75
godot/apigen/apigen.nim
View file

@ -104,12 +104,6 @@ proc postfix(left: PNode, op: string): PNode =
result.add(ident(op)) result.add(ident(op))
result.add(left) result.add(left)
proc newExprColonExpr(key, value: PNode): PNode =
newNode(nkExprColonExpr).addChain(key, value)
proc pragma(key: PNode, value: PNode): PNode =
newNode(nkPragma).addChain(key, value)
proc newBracketExpr(first, bracket: PNode): PNode = proc newBracketExpr(first, bracket: PNode): PNode =
newNode(nkBracketExpr).addChain(first, bracket) newNode(nkBracketExpr).addChain(first, bracket)
@ -263,9 +257,9 @@ const standardTypes = toSet(
"uint64", "uint64",
"int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2", "int64", "float32", "cfloat", "float64", "GodotString", "Vector2", "Rect2",
"Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform", "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform",
"Color", "NodePath", "RID", "Dictionary", "Array", "PoolByteArray", "Color", "RID", "NodePath", "Dictionary", "Variant", "Array",
"PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray",
"PoolVector3Array", "PoolColorArray", "Variant"]) "PoolVector2Array", "PoolVector3Array", "PoolColorArray"])
const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32", const smallIntTypes = toSet(["uint8", "int8", "uint16", "int16", "uint32", "int32",
"cint", "int", "Error"]) "cint", "int", "Error"])
@ -277,6 +271,12 @@ const floatTypes = union(float64Types, float32Types)
const arrayTypes = toSet(["Array", "PoolByteArray", const arrayTypes = toSet(["Array", "PoolByteArray",
"PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array",
"PoolVector3Array", "PoolColorArray"]) "PoolVector3Array", "PoolColorArray"])
const wrapperTypes = union(arrayTypes,
toSet(["NodePath", "Dictionary", "Variant"]))
proc getInternalPtr(varName: PNode, typ: string): PNode =
assert(typ in wrapperTypes)
result = newDotExpr(varName, ident("godot" & typ))
proc newNilCheck(ident, toAssign: PNode): PNode = proc newNilCheck(ident, toAssign: PNode): PNode =
newIfStmt(newCall("isNil", ident), newIfStmt(newCall("isNil", ident),
@ -301,7 +301,7 @@ proc makeDefaultValue(arg: MethodArg): PNode =
result = newFloatLit(parseFloat(arg.defaultVal.str)) result = newFloatLit(parseFloat(arg.defaultVal.str))
elif arg.defaultVal.str == "Null": elif arg.defaultVal.str == "Null":
if arg.typ == "Variant": if arg.typ == "Variant":
result = newCall("variant") result = newCall("newVariant")
else: else:
result = newNilLit() result = newNilLit()
elif arg.typ == "Color": elif arg.typ == "Color":
@ -376,7 +376,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
newNode(nkPtrTy).addChain( newNode(nkPtrTy).addChain(
newNode(nkBracketExpr).addChain( newNode(nkBracketExpr).addChain(
ident("array"), ident("MAX_ARG_COUNT"), ident("array"), ident("MAX_ARG_COUNT"),
if isVarargs: ident("Variant") else: ident("pointer")))) if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant"))
else: ident("pointer"))))
staticArgsLen = if varargsName.isNil: args.len staticArgsLen = if varargsName.isNil: args.len
else: args.len - 1 else: args.len - 1
if not varargsName.isNil: if not varargsName.isNil:
@ -407,7 +408,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen))) newInfix(ident("idx"), ident("-"), newIntLit(staticArgsLen)))
let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx) let argIdx = if arg.isVarargs: ident("idx") else: newIntLit(idx)
let isStandardType = arg.typ in standardTypes let isStandardType = arg.typ in standardTypes
let convArg = if not varargsName.isNil: newCall("toGodot", argName) let isWrappedType = arg.typ in wrapperTypes
let convArg = if not varargsName.isNil:
getInternalPtr(newCall("toGodot", argName), "Variant")
elif isWrappedType: getInternalPtr(argName, arg.typ)
elif isStandardType: newCall("unsafeAddr", argName) elif isStandardType: newCall("unsafeAddr", argName)
elif arg.typ == "string": newCall("unsafeAddr", elif arg.typ == "string": newCall("unsafeAddr",
ident("argToPassToGodot" & $idx)) ident("argToPassToGodot" & $idx))
@ -418,7 +422,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
[arg.typ, godotMethodName, typ.godotName]) [arg.typ, godotMethodName, typ.godotName])
if not isStandardType and varargsName.isNil: if not isStandardType and varargsName.isNil:
if arg.typ == "string": if arg.typ == "string":
argConversions.add(newNode(nkLetSection).addChain( argConversions.add(newNode(nkVarSection).addChain(
newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(), newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(),
newCall("toGodotString", argName)))) newCall("toGodotString", argName))))
else: else:
@ -465,11 +469,6 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
body.add(newNode(nkLetSection).addChain(newIdentDefs( body.add(newNode(nkLetSection).addChain(newIdentDefs(
ident("self"), newNode(nkEmpty), varName ident("self"), newNode(nkEmpty), varName
))) )))
if not varargsName.isNil:
body.add(
pragma(ident("push"), newExprColonExpr(
newBracketExpr(ident("warning"), ident("Destructor")),
ident("off"))))
body.add(nilCheck) body.add(nilCheck)
body.add(vars) body.add(vars)
body.add(argConversions) body.add(argConversions)
@ -482,9 +481,10 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
var isConversionRet: bool var isConversionRet: bool
var isObjRet: bool var isObjRet: bool
var isStringRet: bool var isStringRet: bool
var isWrapperRet: bool
let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName) let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName)
if not returnType.isNil and varargsName.isNil: if not returnType.isNil and not isVarargs:
var addrToAssign = newCall("addr", ident("ptrCallVal")) var addrToAssign = newCall("addr", retValIdent)
if returnType in smallIntTypes: if returnType in smallIntTypes:
isConversionRet = true isConversionRet = true
body.add(newNode(nkVarSection).addChain(newIdentDefs( body.add(newNode(nkVarSection).addChain(newIdentDefs(
@ -495,6 +495,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
body.add(newNode(nkVarSection).addChain(newIdentDefs( body.add(newNode(nkVarSection).addChain(newIdentDefs(
retValIdent, ident("float64"), retValIdent, ident("float64"),
))) )))
elif returnType in wrapperTypes:
isWrapperRet = true
body.add(newNode(nkVarSection).addChain(newIdentDefs(
retValIdent, ident("Godot" & returnType),
)))
elif returnType in standardTypes: elif returnType in standardTypes:
addrToAssign = newCall("addr", ident("result")) addrToAssign = newCall("addr", ident("result"))
elif returnType == "string": elif returnType == "string":
@ -520,9 +525,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
ident(retName), newNode(nkPragma).addChain(ident("used"))), ident(retName), newNode(nkPragma).addChain(ident("used"))),
newNode(nkEmpty), theCall)) newNode(nkEmpty), theCall))
body.add(callStmt) body.add(callStmt)
# if not returnType.isNil and not varargsName.isNil:
# body.add(newCall("fromGodot", ident("result"), ident(retName))) if varargsName.isNil:
# body.add(newCall("deinit", ident(retName))) for idx, arg in args:
if arg.typ == "string":
body.add(newCall("deinit", ident("argToPassToGodot" & $idx)))
if args.len > 0 and not varargsName.isNil: if args.len > 0 and not varargsName.isNil:
body.add(freeCall) body.add(freeCall)
if not varargsName.isNil: if not varargsName.isNil:
@ -536,7 +544,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
if isVariantRet: if isVariantRet:
let convErrDef = newNode(nkLetSection).addChain( let convErrDef = newNode(nkLetSection).addChain(
newIdentDefs(ident("convErr"), newNode(nkEmpty), newIdentDefs(ident("convErr"), newNode(nkEmpty),
newCall("fromGodot", ident("result"), retValIdent))) newCall("fromGodot", ident("result"), newCall("newVariant", retValIdent))))
let convCheck = newIfStmt( let convCheck = newIfStmt(
newInfix(ident("convErr"), ident("!="), newInfix(ident("convErr"), ident("!="),
newDotExpr(ident("ConversionResult"), ident("OK"))), newDotExpr(ident("ConversionResult"), ident("OK"))),
@ -545,12 +553,16 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
) )
body.add(convErrDef) body.add(convErrDef)
body.add(convCheck) body.add(convCheck)
if not isVarargs and (isVariantRet or isStringRet): if isStringRet:
# varargs use call with "let" so destructor is invoked
body.add(newCall("deinit", retValIdent)) body.add(newCall("deinit", retValIdent))
elif isConversionRet: elif isConversionRet:
body.add(newNode(nkAsgn).addChain(ident("result"), body.add(newNode(nkAsgn).addChain(
newCall(returnType, retValIdent))) ident("result"),
newCall(returnType, retValIdent)))
elif isWrapperRet:
body.add(newNode(nkAsgn).addChain(
ident("result"),
newCall("new" & returnType, retValIdent)))
elif isObjRet: elif isObjRet:
body.add(newNode(nkAsgn).addChain(ident("result"), body.add(newNode(nkAsgn).addChain(ident("result"),
newCall(newBracketExpr(ident("asNimGodotObject"), newCall(newBracketExpr(ident("asNimGodotObject"),
@ -558,11 +570,6 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
elif isStringRet: elif isStringRet:
body.add(newNode(nkAsgn).addChain(ident("result"), body.add(newNode(nkAsgn).addChain(ident("result"),
newCall("$", retValIdent))) newCall("$", retValIdent)))
if not varargsName.isNil:
body.add(
pragma(ident("push"), newExprColonExpr(
newBracketExpr(ident("warning"), ident("Destructor")),
ident("on"))))
let procType = if isVirtual: nkMethodDef let procType = if isVirtual: nkMethodDef
else: nkProcDef else: nkProcDef
@ -770,7 +777,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) =
let importStmt = newNode(nkImportStmt) let importStmt = newNode(nkImportStmt)
importStmt.add(ident("godot")) importStmt.add(ident("godot"))
importStmt.add(ident("godottypes")) importStmt.add(ident("godottypes"))
importStmt.add(newDotExpr(ident("core"), ident("godotcore"))) importStmt.add(ident("godotinternal"))
tree.add(importStmt) tree.add(importStmt)
let exportStmt = newNode(nkExportStmt) let exportStmt = newNode(nkExportStmt)
exportStmt.add(ident("godottypes")) exportStmt.add(ident("godottypes"))

216
godot/core/arrays.nim
View file

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

2
godot/core/basis.nim
View file

@ -1,7 +1,7 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import math import math
import godotbase, vector3, quat, strings import godotbase, vector3, quats
type type
Basis* {.byref.} = object Basis* {.byref.} = object

31
godot/core/color.nim → godot/core/colors.nim
View file

@ -1,13 +1,13 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, strings import godotbase
type type
Color* {.byref.} = object Color* {.byref.} = object
r: float32 r*: float32
g: float32 g*: float32
b: float32 b*: float32
a: float32 a*: float32
proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} = proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} =
Color( Color(
@ -38,10 +38,23 @@ proc `$`*(self: Color): string {.inline.} =
result.add(", ") result.add(", ")
result.add($self.a) result.add($self.a)
proc toHtml*(self: Color; with_alpha: bool): GodotString {. proc toHex(val: float32, target: var string, targetIdx: int) =
importc: "godot_color_to_html".} let val = clamp(int(val * 255), 0, 255)
let nums = [(val and 0xF0) shr 4, val and 0xF]
for i, num in nums:
target[targetIdx + i] = if num < 10: chr(ord('0') + num)
else: chr(ord('A') + (num - 10))
proc toARGB32*(self: Color): uint32 = proc toHtml*(self: Color, withAlpha: bool): string =
let size = if withAlpha: 8 else: 6
result = newString(size)
toHex(self.r, result, 0)
toHex(self.g, result, 2)
toHex(self.b, result, 4)
if withAlpha:
toHex(self.b, result, 6)
proc toARGB32*(self: Color): uint32 {.inline.} =
result = uint8(self.a * 255) result = uint8(self.a * 255)
result = (result shl 8) or uint8(self.r * 255) result = (result shl 8) or uint8(self.r * 255)
result = (result shl 8) or uint8(self.g * 255) result = (result shl 8) or uint8(self.g * 255)
@ -58,7 +71,7 @@ proc lerp*(self: Color; b: Color; t: float32): Color {.
proc blend*(self: Color; over: Color): Color {. proc blend*(self: Color; over: Color): Color {.
importc: "godot_color_blend".} importc: "godot_color_blend".}
proc `==`*(a, b: Color): bool = 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.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a
proc `<`*(a, b: Color): bool = proc `<`*(a, b: Color): bool =

93
godot/core/dictionaries.nim Normal file
View file

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

89
godot/core/dictionary.nim
View file

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

114
godot/core/godotbase.nim
View file

@ -57,77 +57,10 @@ type
PrinterOnFire, ## the parallel port printer is engulfed in flames PrinterOnFire, ## the parallel port printer is engulfed in flames
WTF ## shit happens, has never been used, though WTF ## shit happens, has never been used, though
const MAX_ARG_COUNT* = 128
type
GodotObject* = object
Array* {.byref.} = object
p: pointer
Variant* {.byref.} = object
data: array[24, byte]
proc initArray(dest: var Array, src: Array) {.
importc: "godot_array_new_copy".}
proc deinit(self: var Array) {.importc: "godot_array_destroy".}
proc `=`(self: var Array, other: Array) {.inline.} =
initArray(self, other)
proc `=destroy`(self: Array) {.inline.} =
unsafeAddr(self).deinit()
proc initVariant(dest: var Variant; src: Variant) {.
importc: "godot_variant_new_copy".}
proc deinit*(self: var Variant) {.
importc: "godot_variant_destroy".}
proc `=`(self: var Variant, other: Variant) {.inline.} =
initVariant(self, other)
proc `=destroy`(self: Variant) {.inline.} =
unsafeAddr(self).deinit()
# System Functions
proc godotAlloc*(bytes: cint): pointer {.
importc: "godot_alloc".}
## Allocates the specified number of bytes.
## Using this instead of stdlib proc will help Godot track how much memory
## is in use in debug mode.
proc godotRealloc*(p: pointer; bytes: cint): pointer {.
importc: "godot_realloc".}
## Reallocates the pointer for the specified number of bytes.
## Using this instead of stdlib proc will help Godot track how much memory
## is in use in debug mode.
proc godotFree*(p: pointer) {.importc: "godot_free".}
## Frees the memory pointed to by the pointer.
## Using this instead of stdlib proc will help Godot track how much memory
## is in use in debug mode.
# print using Godot's error handler list
proc godotPrintError(description: cstring; function: cstring; file: cstring;
line: cint) {.
importc: "godot_print_error".}
proc godotPrintWarning(description: cstring; function: cstring;
file: cstring; line: cint) {.
importc: "godot_print_warning".}
template printWarning*(warn: typed) =
let (filename, line) = instantiationInfo()
godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint)
template printError*(err: typed) =
let (filename, line) = instantiationInfo()
godotPrintError(cstring($err), nil, cstring(filename), line.cint)
# math helpers # math helpers
const EPSILON = 0.00001'f32 const EPSILON = 0.00001'f32
proc isEqualApprox*(a, b: float32): bool {.inline.} = proc isEqualApprox*(a, b: float32): bool {.inline.} =
abs(a - b) < EPSILON abs(a - b) < EPSILON
proc isEqualApprox*(a, b: float64): bool {.inline.} = proc isEqualApprox*(a, b: float64): bool {.inline.} =
@ -150,3 +83,48 @@ proc stepify*(value, step: float32): float32 =
floor(value / step + 0.5'f32) * step floor(value / step + 0.5'f32) * step
else: else:
value value
import "../internal/godotinternaltypes.nim"
type
Variant* = ref object
godotVariant: GodotVariant
noDeinit: bool # used to avoid copying when passing the variant to Godot
Array* = ref object
godotArray: GodotArray
proc markNoDeinit*(v: Variant) {.inline.} =
## Makes it so that internal GodotVariant object will not be destroyed
## when the reference is gone. Use only if you know what you are doing.
v.noDeinit = true
proc isNoDeinit*(v: Variant): bool {.inline.} =
v.noDeinit
proc godotArray*(arr: Array): ptr GodotArray {.inline.} =
## WARNING: do not keep the returned value for longer than the lifetime of
## ``arr``
addr arr.godotArray
proc godotVariant*(v: Variant): ptr GodotVariant {.inline.} =
## WARNING: do not keep the returned value for longer than the lifetime of
## ``v``
addr v.godotVariant
# System Functions
proc godotAlloc*(bytes: cint): pointer {.
importc: "godot_alloc".}
## Allocates the specified number of bytes.
## Using this instead of stdlib proc will help Godot track how much memory
## is in use in debug mode.
proc godotRealloc*(p: pointer; bytes: cint): pointer {.
importc: "godot_realloc".}
## Reallocates the pointer for the specified number of bytes.
## Using this instead of stdlib proc will help Godot track how much memory
## is in use in debug mode.
proc godotFree*(p: pointer) {.importc: "godot_free".}
## Frees the memory pointed to by the pointer.
## Using this instead of stdlib proc will help Godot track how much memory
## is in use in debug mode.

51
godot/core/nodepath.nim
View file

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

69
godot/core/nodepaths.nim Normal file
View file

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

5
godot/core/plane.nim → godot/core/planes.nim
View file

@ -1,6 +1,8 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, vector3, strings import godotbase, vector3
import "../internal/godotstrings.nim"
type type
Plane* {.byref.} = object Plane* {.byref.} = object
@ -26,6 +28,7 @@ proc initPlane*(normal: Vector3; d: float32): Plane =
proc toGodotString(self: Plane): GodotString {. proc toGodotString(self: Plane): GodotString {.
noSideEffect, noSideEffect,
importc: "godot_plane_as_string".} importc: "godot_plane_as_string".}
proc `$`*(self: Plane): string {.inline.} = proc `$`*(self: Plane): string {.inline.} =
$self.toGodotString() $self.toGodotString()

430
godot/core/poolarray.nim
View file

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

126
godot/core/poolarrays.nim Normal file
View file

@ -0,0 +1,126 @@
# Copyright 2017 Xored Software, Inc.
import godotbase, vector2, vector3, colors
import "../internal/godotpoolarrays.nim", "../internal/godotstrings.nim"
# byte
template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
noData = false) =
type
T* = ref object
fieldName: GodotT
proc poolArrayFinalizer(arr: T) =
arr.fieldName.deinit()
proc newProcName*(): T {.inline.} =
new(result, poolArrayFinalizer)
initProcName(result.fieldName)
proc newProcName*(arr: Array): T {.inline.} =
new(result, poolArrayFinalizer)
initProcName(result.fieldName, arr.godotArray[])
proc newProcName*(arr: GodotT): T {.inline.} =
new(result, poolArrayFinalizer)
result.fieldName = arr
proc add*(self: var T; arr: T) {.inline.} =
self.fieldName.add(arr.fieldName)
proc delete*(self: var T; idx: int) {.inline.} =
self.fieldName.delete(idx.cint)
proc reverse*(self: var T) {.inline.} =
self.fieldName.reverse()
proc setLen*(self: var T; size: int) {.inline.} =
self.fieldName.setLen(size.cint)
proc len*(self: T): int {.inline.} =
self.fieldName.len.int
proc fieldName*(self: T): ptr GodotT {.inline.} =
## WARNING: do not keep the returned value for longer than the lifetime of
## the array.
addr self.fieldName
when not noData:
proc add*(self: var T; data: DataT) {.inline.} =
self.fieldName.add(data)
proc addFirst*(self: var T, data: DataT) {.inline.} =
self.fieldName.addFirst(data)
proc insert*(self: var T; idx: int; data: DataT): Error {.inline.} =
self.fieldName.insert(idx.cint, data)
proc `[]=`*(self: var T; idx: int; data: DataT) {.inline.} =
self.fieldName[idx.cint] = data
proc `[]`*(self: T; idx: int): DataT {.inline.} =
self.fieldName[idx.cint]
iterator items*(arr: T): DataT =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: T): tuple[key: int, val: DataT] =
for i in 0..<arr.len:
yield (i, arr[i])
definePoolArray(PoolByteArray, GodotPoolByteArray, uint8,
godotPoolByteArray, newPoolByteArray,
initGodotPoolByteArray)
definePoolArray(PoolIntArray, GodotPoolIntArray, cint,
godotPoolIntArray, newPoolIntArray,
initGodotPoolIntArray)
definePoolArray(PoolRealArray, GodotPoolRealArray, float64,
godotPoolRealArray, newPoolRealArray,
initGodotPoolRealArray)
definePoolArray(PoolVector2Array, GodotPoolVector2Array, Vector2,
godotPoolVector2Array, newPoolVector2Array,
initGodotPoolVector2Array)
definePoolArray(PoolVector3Array, GodotPoolVector3Array, Vector3,
godotPoolVector3Array, newPoolVector3Array,
initGodotPoolVector3Array)
definePoolArray(PoolColorArray, GodotPoolColorArray, Color,
godotPoolColorArray, newPoolColorArray,
initGodotPoolColorArray)
definePoolArray(PoolStringArray, GodotPoolStringArray, string,
godotPoolStringArray, newPoolStringArray,
initGodotPoolStringArray, true)
proc add*(self: var PoolStringArray; data: string) =
var s = data.toGodotString()
self.godotPoolStringArray.add(s)
s.deinit()
proc addFirst*(self: var PoolStringArray, data: string) =
var s = data.toGodotString()
self.godotPoolStringArray.addFirst(s)
s.deinit()
proc insert*(self: var PoolStringArray; idx: int; data: string): Error =
var s = data.toGodotString()
result = self.godotPoolStringArray.insert(idx.cint, s)
s.deinit()
proc `[]=`*(self: var PoolStringArray; idx: int; data: string) =
var s = data.toGodotString()
self.godotPoolStringArray[idx.cint] = s
s.deinit()
proc `[]`*(self: PoolStringArray; idx: int): string =
var s = self.godotPoolStringArray[idx.cint]
result = $s
s.deinit()
iterator items*(arr: PoolStringArray): string =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: PoolStringArray): tuple[key: int, val: string] =
for i in 0..<arr.len:
yield (i, arr[i])

31
godot/core/quat.nim → godot/core/quats.nim
View file

@ -1,6 +1,7 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, vector3, strings import godotbase, vector3
import "../internal/godotstrings.nim"
type type
Quat* {.byref.} = object Quat* {.byref.} = object
@ -20,34 +21,10 @@ proc initQuat*(x, y, z, w: float32): Quat {.inline.} =
proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} = proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} =
initQuat(result, axis, angle) initQuat(result, axis, angle)
proc x*(self: Quat): float32 {. proc toGodotString(self: Quat): GodotString {.
noSideEffect,
importc: "godot_quat_get_x".}
proc `x=`*(self: var Quat; val: float32) {.
noSideEffect,
importc: "godot_quat_set_x".}
proc y*(self: Quat): float32 {.
noSideEffect,
importc: "godot_quat_get_y".}
proc `y=`*(self: var Quat; val: float32) {.
noSideEffect,
importc: "godot_quat_set_y".}
proc z*(self: Quat): float32 {.
noSideEffect,
importc: "godot_quat_get_z".}
proc `z=`*(self: var Quat; val: float32) {.
noSideEffect,
importc: "godot_quat_set_z".}
proc w*(self: Quat): float32 {.
noSideEffect,
importc: "godot_quat_get_w".}
proc `w=`*(self: var Quat; val: float32) {.
noSideEffect,
importc: "godot_quat_set_w".}
proc toGodotString*(self: Quat): GodotString {.
noSideEffect, noSideEffect,
importc: "godot_quat_as_string".} importc: "godot_quat_as_string".}
proc `$`*(self: Quat): string {.inline.} = proc `$`*(self: Quat): string {.inline.} =
$self.toGodotString() $self.toGodotString()

7
godot/core/rect2.nim
View file

@ -1,6 +1,8 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, vector2, strings import godotbase, vector2
import "../internal/godotstrings.nim"
type type
Rect2* {.byref.} = object Rect2* {.byref.} = object
@ -13,9 +15,10 @@ proc initRect2*(pos, size: Vector2): Rect2 {.inline.} =
proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline.} = proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline.} =
Rect2(position: vec2(x, y), size: vec2(sizeX, sizeY)) Rect2(position: vec2(x, y), size: vec2(sizeX, sizeY))
proc toGodotString*(self: Rect2): GodotString {. proc toGodotString(self: Rect2): GodotString {.
noSideEffect, noSideEffect,
importc: "godot_rect2_as_string".} importc: "godot_rect2_as_string".}
proc `$`*(self: Rect2): string {.inline.} = proc `$`*(self: Rect2): string {.inline.} =
$self.toGodotString() $self.toGodotString()

8
godot/core/rect3.nim
View file

@ -1,6 +1,8 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, plane, vector3, strings import godotbase, planes, vector3
import "../internal/godotstrings.nim"
type type
Rect3* {.byref.} = object Rect3* {.byref.} = object
@ -10,11 +12,13 @@ type
proc initRect3*(pos, size: Vector3): Rect3 {.inline.} = proc initRect3*(pos, size: Vector3): Rect3 {.inline.} =
Rect3(position: pos, size: size) Rect3(position: pos, size: size)
proc toGodotString*(self: Rect3): GodotString {. proc toGodotString(self: Rect3): GodotString {.
noSideEffect, noSideEffect,
importc: "godot_rect3_as_string".} importc: "godot_rect3_as_string".}
proc `$`*(self: Rect3): string {.inline.} = proc `$`*(self: Rect3): string {.inline.} =
$self.toGodotString() $self.toGodotString()
proc area*(self: Rect3): float32 {. proc area*(self: Rect3): float32 {.
noSideEffect, noSideEffect,
importc: "godot_rect3_get_area".} importc: "godot_rect3_get_area".}

2
godot/core/rid.nim → godot/core/rids.nim
View file

@ -1,5 +1,7 @@
import godotbase import godotbase
import "../internal/godotinternaltypes.nim"
type type
RID* {.byref.} = object RID* {.byref.} = object
p: pointer p: pointer

10
godot/core/transform2d.nim
View file

@ -1,10 +1,12 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, strings, vector2, rect2 import godotbase, vector2, rect2
import "../internal/godotstrings.nim"
type type
Transform2D* {.byref.} = object Transform2D* {.byref.} = object
elements: array[3, Vector2] elements*: array[3, Vector2]
proc initTransform2D(dest: var Transform2D) {. proc initTransform2D(dest: var Transform2D) {.
importc: "godot_transform2d_new_identity".} importc: "godot_transform2d_new_identity".}
@ -22,8 +24,9 @@ proc initTransform2D*(rot: float32; pos: Vector2): Transform2D {.inline.} =
proc initTransform2D*(xAxis, yAxis, origin: Vector2): Transform2D {.inline.} = proc initTransform2D*(xAxis, yAxis, origin: Vector2): Transform2D {.inline.} =
initTransform2D(result, xAxis, yAxis, origin) initTransform2D(result, xAxis, yAxis, origin)
proc toGodotString*(self: Transform2D): GodotString {. proc toGodotString(self: Transform2D): GodotString {.
importc: "godot_transform2d_as_string".} importc: "godot_transform2d_as_string".}
proc `$`*(self: Transform2D): string {.inline.} = proc `$`*(self: Transform2D): string {.inline.} =
$self.toGodotString() $self.toGodotString()
@ -71,4 +74,3 @@ proc `*`*(a, b: Transform2D): Transform2D {.
proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} = proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} =
a = a * b a = a * b

7
godot/core/transform.nim → godot/core/transforms.nim
View file

@ -1,6 +1,8 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, basis, vector3, strings, plane, rect3 import godotbase, basis, vector3, planes, rect3
import "../internal/godotstrings.nim"
type type
Transform* {.byref.} = object Transform* {.byref.} = object
@ -21,8 +23,9 @@ proc initTransform*(xAxis, yAxis, zAxis,
proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} = proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} =
Transform(basis: basis, origin: origin) Transform(basis: basis, origin: origin)
proc toGodotString*(self: Transform): GodotString {. proc toGodotString(self: Transform): GodotString {.
importc: "godot_transform_as_string".} importc: "godot_transform_as_string".}
proc `$`*(self: Transform): string {.inline.} = proc `$`*(self: Transform): string {.inline.} =
$self.toGodotString() $self.toGodotString()

269
godot/core/variant.nim
View file

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

251
godot/core/variants.nim Normal file
View file

@ -0,0 +1,251 @@
import tables
import godotbase
import basis, nodepaths
import planes, poolarrays, quats, rect2, rect3, rids
import transforms, transform2d, vector2
import vector3, colors
import "../internal/godotinternaltypes.nim"
import "../internal/godotvariants.nim", "../internal/godotpoolarrays.nim",
"../internal/godotstrings.nim", "../internal/godotnodepaths.nim"
export VariantType, VariantCallErrorType, VariantCallError
proc getType*(v: Variant): VariantType =
v.godotVariant[].getType()
proc variantFinalizer(v: Variant) =
if not v.isNoDeinit:
v.godotVariant[].deinit()
proc newVariant*(): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[])
proc newVariant*(v: Variant): Variant {.inline.} =
## Makes a copy
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], v.godotVariant[])
proc newVariant*(v: GodotVariant): Variant {.inline.} =
new(result, variantFinalizer)
result.godotVariant[] = v
proc newVariant*(b: bool): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], b)
proc newVariant*(i: uint64): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], i)
proc newVariant*(i: int64): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], i)
proc newVariant*(r: cdouble): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], r)
proc newVariant*(s: GodotString): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], s)
proc newVariant*(s: string): Variant {.inline.} =
new(result, variantFinalizer)
var godotStr = s.toGodotString()
initGodotVariant(result.godotVariant[], godotStr)
godotStr.deinit()
proc newVariant*(v2: Vector2): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], v2)
proc newVariant*(rect2: Rect2): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], rect2)
proc newVariant*(v3: Vector3): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], v3)
proc newVariant*(t2d: Transform2D): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], t2d)
proc newVariant*(plane: Plane): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], plane)
proc newVariant*(quat: Quat): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], quat)
proc newVariant*(rect3: Rect3): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], rect3)
proc newVariant*(basis: Basis): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], basis)
proc newVariant*(trans: Transform): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], trans)
proc newVariant*(color: Color): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], color)
proc newVariant*(nodePath: NodePath): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], nodePath.godotNodePath[])
proc newVariant*(godotNodePath: GodotNodePath): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], godotNodePath)
proc newVariant*(rid: RID): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], rid)
proc newVariant*(obj: ptr GodotObject): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], obj)
import arrays
proc newVariant*(arr: Array): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], arr.godotArray[])
proc newVariant*(pba: PoolByteArray): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], pba.godotPoolByteArray[])
proc newVariant*(pia: PoolIntArray): Variant {.inline.} =
initGodotVariant(result.godotVariant[], pia.godotPoolIntArray[])
proc newVariant*(pra: PoolRealArray): Variant {.inline.} =
initGodotVariant(result.godotVariant[], pra.godotPoolRealArray[])
proc newVariant*(psa: PoolStringArray): Variant {.inline.} =
initGodotVariant(result.godotVariant[], psa.godotPoolStringArray[])
proc newVariant*(pv2a: PoolVector2Array): Variant {.inline.} =
initGodotVariant(result.godotVariant[], pv2a.godotPoolVector2Array[])
proc newVariant*(pv3a: PoolVector3Array): Variant {.inline.} =
initGodotVariant(result.godotVariant[], pv3a.godotPoolVector3Array[])
proc newVariant*(pca: PoolColorArray): Variant {.inline.} =
initGodotVariant(result.godotVariant[], pca.godotPoolColorArray[])
import dictionaries
proc newVariant*(dict: Dictionary): Variant {.inline.} =
new(result, variantFinalizer)
initGodotVariant(result.godotVariant[], dict.godotDictionary[])
proc asBool*(self: Variant): bool {.inline.} =
self.godotVariant[].asBool()
proc asUInt*(self: Variant): uint64 =
self.godotVariant[].asUInt()
proc asInt*(self: Variant): int64 =
self.godotVariant[].asInt()
proc asReal*(self: Variant): cdouble =
self.godotVariant[].asReal()
proc asString*(self: Variant): string =
var s = self.godotVariant[].asGodotString()
result = $s
s.deinit()
proc asVector2*(self: Variant): Vector2 =
self.godotVariant[].asVector2()
proc asRect2*(self: Variant): Rect2 =
self.godotVariant[].asRect2()
proc asVector3*(self: Variant): Vector3 =
self.godotVariant[].asVector3()
proc asTransform2D*(self: Variant): Transform2D =
self.godotVariant[].asTransform2D()
proc asPlane*(self: Variant): Plane =
self.godotVariant[].asPlane()
proc asQuat*(self: Variant): Quat =
self.godotVariant[].asQuat()
proc asRect3*(self: Variant): Rect3 =
self.godotVariant[].asRect3()
proc asBasis*(self: Variant): Basis =
self.godotVariant[].asBasis()
proc asTransform*(self: Variant): Transform =
self.godotVariant[].asTransform()
proc asColor*(self: Variant): Color =
self.godotVariant[].asColor()
proc asNodePath*(self: Variant): NodePath =
result = newNodePath(self.godotVariant[].asNodePath())
proc asRID*(self: Variant): RID =
self.godotVariant[].asRID()
proc asGodotObject*(self: Variant): ptr GodotObject =
self.godotVariant[].asGodotObject()
proc asArray*(self: Variant): Array =
newArray(self.godotVariant[].asGodotArray())
proc asPoolByteArray*(self: Variant): PoolByteArray =
newPoolByteArray(self.godotVariant[].asGodotPoolByteArray())
proc asPoolIntArray*(self: Variant): PoolIntArray =
newPoolIntArray(self.godotVariant[].asGodotPoolIntArray())
proc asPoolRealArray*(self: Variant): PoolRealArray =
newPoolRealArray(self.godotVariant[].asGodotPoolRealArray())
proc asPoolStringArray*(self: Variant): PoolStringArray =
newPoolStringArray(self.godotVariant[].asGodotPoolStringArray())
proc asPoolVector2Array*(self: Variant): PoolVector2Array =
newPoolVector2Array(self.godotVariant[].asGodotPoolVector2Array())
proc asPoolVector3Array*(self: Variant): PoolVector3Array =
newPoolVector3Array(self.godotVariant[].asGodotPoolVector3Array())
proc asPoolColorArray*(self: Variant): PoolColorArray =
newPoolColorArray(self.godotVariant[].asGodotPoolColorArray())
proc asDictionary*(self: Variant): Dictionary {.inline.} =
newDictionary(self.godotVariant[].asGodotDictionary)
proc hasMethod*(self: Variant; meth: string): bool =
var s = meth.toGodotString()
result = self.godotVariant[].hasMethod(s)
s.deinit()
proc `==`*(self, other: Variant): bool =
if self.isNil and other.isNil: return true
if self.isNil != other.isNil: return false
result = self.godotVariant[] == other.godotVariant[]
proc `<`*(self, other: Variant): bool =
result = self.godotVariant[] < other.godotVariant[]
proc hashCompare*(self, other: Variant): bool =
self.godotVariant[].hashCompare(other.godotVariant[])
proc booleanize*(self: Variant; isValid: var bool): bool =
self.godotVariant[].booleanize(isValid)

7
godot/core/vector2.nim
View file

@ -1,6 +1,8 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase, strings import godotbase
import "../internal/godotstrings.nim"
type type
Vector2* {.byref.} = object Vector2* {.byref.} = object
@ -10,8 +12,9 @@ type
proc vec2*(x, y: float32): Vector2 {.inline.} = proc vec2*(x, y: float32): Vector2 {.inline.} =
Vector2(x: x, y: y) Vector2(x: x, y: y)
proc toGodotString*(self: Vector2): GodotString {. proc toGodotString(self: Vector2): GodotString {.
importc: "godot_vector2_as_string".} importc: "godot_vector2_as_string".}
proc `$`*(self: Vector2): string {.inline.} = proc `$`*(self: Vector2): string {.inline.} =
$self.toGodotString() $self.toGodotString()

2
godot/core/vector3.nim
View file

@ -1,7 +1,7 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import math import math
import godotbase, strings import godotbase
type type
Vector3* {.byref.} = object Vector3* {.byref.} = object

17
godot/godot.nim
View file

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

58
godot/core/godotcore.nim → godot/godotinternal.nim
View file

@ -1,13 +1,13 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright 2017 Xored Software, Inc.
import godotbase import internal / [
import strings, vector2, rect2, vector3, transform2d, plane, quat godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays,
import rect3, basis, transform, color, nodepath, rid godotstrings, godotvariants, godotdictionaries]
import dictionary, arrays, poolarray, variant
export godotbase, strings, vector2, rect2, vector3, transform2d, plane, quat, export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays,
rect3, basis, transform, color, nodepath, rid, dictionary, arrays, godotstrings, godotvariants, godotdictionaries
poolarray, variant
const MAX_ARG_COUNT* = 128
# MethodBind API # MethodBind API
@ -22,8 +22,8 @@ proc ptrCall*(methodBind: ptr GodotMethodBind;
importc: "godot_method_bind_ptrcall".} importc: "godot_method_bind_ptrcall".}
proc call*(methodBind: ptr GodotMethodBind; proc call*(methodBind: ptr GodotMethodBind;
instance: ptr GodotObject; instance: ptr GodotObject;
args: var ptr array[MAX_ARG_COUNT, Variant]; argCount: cint; args: ptr array[MAX_ARG_COUNT, ptr GodotVariant]; argCount: cint;
callError: var VariantCallError): Variant {. callError: var VariantCallError): GodotVariant {.
importc: "godot_method_bind_call".} importc: "godot_method_bind_call".}
# Script API # Script API
@ -151,7 +151,7 @@ type
hint*: GodotPropertyHint hint*: GodotPropertyHint
hintString*: GodotString hintString*: GodotString
usage*: GodotPropertyUsageFlags usage*: GodotPropertyUsageFlags
defaultValue*: Variant defaultValue*: GodotVariant
GodotInstanceCreateFunc* {.bycopy.} = object GodotInstanceCreateFunc* {.bycopy.} = object
createFunc*: createFunc*:
@ -180,7 +180,8 @@ type
meth*: meth*:
proc (obj: ptr GodotObject; methodData: pointer; proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer; numArgs: cint; userData: pointer; numArgs: cint;
args: var ptr array[MAX_ARG_COUNT, Variant]): Variant {.noconv.} args: var ptr array[MAX_ARG_COUNT, GodotVariant]):
GodotVariant {.noconv.}
methodData*: pointer methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.} freeFunc*: proc (a2: pointer) {.noconv.}
@ -192,13 +193,13 @@ proc godotScriptRegisterMethod*(libHandle: pointer;
type type
GodotPropertySetFunc* {.bycopy.} = object GodotPropertySetFunc* {.bycopy.} = object
setFunc*: proc (obj: ptr GodotObject; methodData: pointer; setFunc*: proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer; value: Variant) {.noconv.} userData: pointer; value: GodotVariant) {.noconv.}
methodData*: pointer methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.} freeFunc*: proc (a2: pointer) {.noconv.}
GodotPropertyGetFunc* {.bycopy.} = object GodotPropertyGetFunc* {.bycopy.} = object
getFunc*: proc (obj: ptr GodotObject; methodData: pointer; getFunc*: proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer): Variant {.noconv.} userData: pointer): GodotVariant {.noconv.}
methodData*: pointer methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.} freeFunc*: proc (a2: pointer) {.noconv.}
@ -216,14 +217,15 @@ type
hint*: GodotPropertyHint hint*: GodotPropertyHint
hintString*: GodotString hintString*: GodotString
usage*: GodotPropertyUsageFlags usage*: GodotPropertyUsageFlags
defaultValue*: Variant defaultValue*: GodotVariant
GodotSignal* = object GodotSignal* = object
name*: GodotString name*: GodotString
numArgs*: cint numArgs*: cint
args*: ptr GodotSignalArgument args*: ptr GodotSignalArgument
numDefaultArgs*: cint numDefaultArgs*: cint
defaultArgs*: ptr Variant defaultArgs*: ptr GodotVariant
proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring; proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring;
signal: GodotSignal) {. signal: GodotSignal) {.
@ -240,3 +242,27 @@ proc godotStackBottom*(): pointer {.
proc deinit*(o: ptr GodotObject) {. proc deinit*(o: ptr GodotObject) {.
importc: "godot_object_destroy".} importc: "godot_object_destroy".}
# print using Godot's error handler list
proc godotPrintError*(description: cstring; function: cstring; file: cstring;
line: cint) {.
importc: "godot_print_error".}
proc godotPrintWarning*(description: cstring; function: cstring;
file: cstring; line: cint) {.
importc: "godot_print_warning".}
proc godotPrint*(message: GodotString) {.
importc: "godot_print".}
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.len > 2 and result[^2] == 'S' and result[^1] == 'W':
# There are physics type not known by ClassDB
result = result[0..result.len-3]

115
godot/internal/godotarrays.nim Normal file
View file

@ -0,0 +1,115 @@
# Copyright (c) 2017 Xored Software, Inc.
import hashes
import godotinternaltypes, godotpoolarrays, godotvariants, godotstrings
proc initGodotArray*(dest: var GodotArray) {.
importc: "godot_array_new".}
proc initGodotArray*(dest: var GodotArray; pca: GodotPoolColorArray) {.
importc: "godot_array_new_pool_coloarray".}
proc initGodotArray*(dest: var GodotArray; pv3a: GodotPoolVector3Array) {.
importc: "godot_array_new_pool_vector3_array".}
proc initGodotArray*(dest: var GodotArray; pv2a: GodotPoolVector2Array) {.
importc: "godot_array_new_pool_vector2_array".}
proc initGodotArray*(dest: var GodotArray; psa: GodotPoolStringArray) {.
importc: "godot_array_new_pool_string_array".}
proc initGodotArray*(dest: var GodotArray; pra: GodotPoolRealArray) {.
importc: "godot_array_new_pool_real_array".}
proc initGodotArray*(dest: var GodotArray; pia: GodotPoolIntArray) {.
importc: "godot_array_new_pool_int_array".}
proc initGodotArray*(dest: var GodotArray; pba: GodotPoolByteArray) {.
importc: "godot_array_new_pool_byte_array".}
proc iniGodotArray*(dest: var GodotArray; src: GodotArray) {.
importc: "godot_array_new_copy".}
proc deinit*(self: var GodotArray) {.importc: "godot_array_destroy".}
proc `[]=`*(self: var GodotArray; idx: cint;
value: GodotVariant) {.
noSideEffect,
importc: "godot_array_set".}
proc `[]`*(self: GodotArray; idx: cint): GodotVariant {.
noSideEffect,
importc: "godot_array_get".}
proc mget*(self: var GodotArray; idx: cint): ptr GodotVariant {.
importc: "godot_array_operator_index".}
proc add*(self: var GodotArray; value: GodotVariant) {.
noSideEffect,
importc: "godot_array_append".}
proc clear*(self: var GodotArray) {.importc: "godot_array_clear".}
proc count*(self: GodotArray; value: GodotVariant): cint {.
noSideEffect,
importc: "godot_array_count".}
proc isEmpty*(self: GodotArray): bool {.
noSideEffect,
importc: "godot_array_empty".}
proc erase*(self: var GodotArray; value: GodotVariant) {.
importc: "godot_array_erase".}
proc first*(self: GodotArray): GodotVariant {.
noSideEffect,
importc: "godot_array_front".}
proc last*(self: GodotArray): GodotVariant {.
noSideEffect,
importc: "godot_array_back".}
proc find*(self: GodotArray; what: GodotVariant;
f: cint): cint {.
noSideEffect,
importc: "godot_array_find".}
proc findLast*(self: GodotArray; what: GodotVariant): cint {.
noSideEffect,
importc: "godot_array_find_last".}
proc contains*(self: GodotArray; value: GodotVariant): bool {.
noSideEffect,
importc: "godot_array_has".}
proc godotHash*(self: GodotArray): cint {.
noSideEffect,
importc: "godot_array_hash".}
proc hash*(self: GodotArray): Hash {.inline.} =
hash(godotHash(self))
proc insert*(self: var GodotArray; pos: cint;
value: GodotVariant) {.
importc: "godot_array_insert".}
proc reverse*(self: var GodotArray) {.importc: "godot_array_invert".}
proc popLast*(self: var GodotArray): GodotVariant {.
importc: "godot_array_pop_back".}
proc popFirst*(self: var GodotArray): GodotVariant {.
importc: "godot_array_pop_front".}
proc addLast*(self: var GodotArray; value: GodotVariant) {.
importc: "godot_array_push_back".}
proc addFirst*(self: var GodotArray; value: GodotVariant) {.
importc: "godot_array_push_front".}
proc delete*(self: var GodotArray; idx: cint) {.
importc: "godot_array_remove".}
proc setLen*(self: var GodotArray; size: cint) {.
importc: "godot_array_resize".}
proc rfind*(self: GodotArray; what: GodotVariant;
f: cint): cint {.
noSideEffect,
importc: "godot_array_rfind".}
proc len*(self: GodotArray): cint {.
noSideEffect,
importc: "godot_array_size".}
proc sort*(self: var GodotArray) {.importc: "godot_array_sort".}
proc sortCustom*(self: var GodotArray; obj: var GodotObject;
funcName: GodotString) {.
importc: "godot_array_sort_custom".}
iterator items*(arr: GodotArray): GodotVariant =
for i in 0..<arr.len:
yield arr[i]
iterator mitems*(arr: var GodotArray): var GodotVariant =
for i in 0..<arr.len:
yield arr.mget(i)[]
iterator pairs*(arr: GodotArray): tuple[key: cint, val: GodotVariant] =
for i in 0..<arr.len:
yield (i, arr[i])
iterator mpairs*(arr: var GodotArray): tuple[key: cint, val: var GodotVariant] =
for i in 0..<arr.len:
yield (i, arr.mget(i)[])

48
godot/internal/godotdictionaries.nim Normal file
View file

@ -0,0 +1,48 @@
# Copyright (c) 2017 Xored Software, Inc.
type
GodotDictionary* {.byref.} = object
p: pointer
import godotinternaltypes, godotarrays, godotvariants, godotstrings
proc initGodotDictionary*(dest: var GodotDictionary; src: GodotDictionary) {.
importc: "godot_dictionary_new_copy".}
proc deinit*(self: var GodotDictionary) {.
importc: "godot_dictionary_destroy".}
proc initGodotDictionary*(dest: var GodotDictionary) {.
importc: "godot_dictionary_new".}
proc len*(self: GodotDictionary): cint {.
importc: "godot_dictionary_size".}
proc isEmpty*(self: GodotDictionary): bool {.
importc: "godot_dictionary_empty".}
proc clear*(self: var GodotDictionary) {.
importc: "godot_dictionary_clear".}
proc contains*(self: GodotDictionary; key: GodotVariant): bool {.
importc: "godot_dictionary_has".}
proc contains*(self: GodotDictionary; keys: GodotArray): bool {.
importc: "godot_dictionary_has_all".}
proc del*(self: var GodotDictionary; key: GodotVariant) {.
importc: "godot_dictionary_erase".}
proc godotHash*(self: GodotDictionary): cint {.
importc: "godot_dictionary_hash".}
proc keys*(self: GodotDictionary): GodotArray {.
importc: "godot_dictionary_keys".}
proc values*(self: GodotDictionary): GodotArray {.
importc: "godot_dictionary_values".}
proc `[]`*(self: GodotDictionary; key: GodotVariant): GodotVariant {.
importc: "godot_dictionary_get".}
proc `[]=`*(self: var GodotDictionary; key, value: GodotVariant) {.
importc: "godot_dictionary_set".}
proc mget*(self: var GodotDictionary; key: GodotVariant): ptr GodotVariant {.
importc: "godot_dictionary_operator_index".}
proc `==`*(self, other: GodotDictionary): bool {.
importc: "godot_dictionary_operator_equal".}
proc toJson*(self: GodotDictionary): GodotString {.
importc: "godot_dictionary_to_json".}

8
godot/internal/godotinternaltypes.nim Normal file
View file

@ -0,0 +1,8 @@
# Copyright 2017 Xored Software, Inc.
type
GodotObject* = object
GodotArray* {.byref.} = object
p: pointer
GodotVariant* {.byref.} = object
data: array[24, byte]

32
godot/internal/godotnodepaths.nim Normal file
View file

@ -0,0 +1,32 @@
# Copyright 2017 Xored Software, Inc.
import godotstrings
type
GodotNodePath* {.byref.} = object
p: pointer
proc initGodotNodePath*(dest: var GodotNodePath; s: GodotString) {.
importc: "godot_node_path_new".}
proc deinit*(self: var GodotNodePath) {.
importc: "godot_node_path_destroy".}
proc toGodotString*(self: GodotNodePath): GodotString {.
importc: "godot_node_path_as_string".}
proc isAbsolute*(self: GodotNodePath): bool {.
noSideEffect, importc: "godot_node_path_is_absolute".}
proc nameCount*(self: GodotNodePath): cint {.
noSideEffect, importc: "godot_node_path_get_name_count".}
proc getName*(self: GodotNodePath; idx: cint): GodotString {.
noSideEffect, importc: "godot_node_path_get_name".}
proc subnameCount*(self: GodotNodePath): cint {.
noSideEffect, importc: "godot_node_path_get_subname_count".}
proc getSubname*(self: GodotNodePath; idx: cint): GodotString {.
noSideEffect, importc: "godot_node_path_get_subname".}
proc property*(self: GodotNodePath): GodotString {.
noSideEffect, importc: "godot_node_path_get_property".}
proc isEmpty*(self: GodotNodePath): bool {.
noSideEffect, importc: "godot_node_path_is_empty".}
proc `==`*(a, b: GodotNodePath): bool {.
noSideEffect, importc: "godot_node_path_operator_equal".}

376
godot/internal/godotpoolarrays.nim Normal file
View file

@ -0,0 +1,376 @@
# Copyright (c) 2017 Xored Software, Inc.
import godotinternaltypes, godotstrings
import "../core/godotbase.nim", "../core/colors.nim",
"../core/vector2.nim", "../core/vector3.nim"
type
GodotPoolByteArray* {.byref.} = object
p: pointer
GodotPoolIntArray* {.byref.} = object
p: pointer
GodotPoolRealArray* {.byref.} = object
p: pointer
GodotPoolStringArray* {.byref.} = object
p: pointer
GodotPoolVector2Array* {.byref.} = object
p: pointer
GodotPoolVector3Array* {.byref.} = object
p: pointer
GodotPoolColorArray* {.byref.} = object
p: pointer
# byte
proc initGodotPoolByteArray*(dest: var GodotPoolByteArray) {.
importc: "godot_pool_byte_array_new".}
proc initGodotPoolByteArray*(dest: var GodotPoolByteArray;
src: GodotPoolByteArray) {.
importc: "godot_pool_byte_array_new_copy".}
proc initGodotPoolByteArray*(dest: var GodotPoolByteArray; arr: GodotArray) {.
importc: "godot_pool_byte_array_new_with_array".}
proc deinit*(self: var GodotPoolByteArray) {.
importc: "godot_pool_byte_array_destroy".}
proc add*(self: var GodotPoolByteArray;
data: uint8) {.
importc: "godot_pool_byte_array_append".}
proc addFirst*(self: var GodotPoolByteArray, data: uint8) {.
importc: "godot_pool_byte_array_push_back".}
proc add*(self: var GodotPoolByteArray;
arr: GodotPoolByteArray) {.
importc: "godot_pool_byte_array_append_array".}
proc insert*(self: var GodotPoolByteArray; idx: cint;
data: uint8): Error {.
importc: "godot_pool_byte_array_insert".}
proc delete*(self: var GodotPoolByteArray; idx: cint) {.
importc: "godot_pool_byte_array_remove".}
proc reverse*(self: var GodotPoolByteArray) {.
importc: "godot_pool_byte_array_invert".}
proc setLen*(self: var GodotPoolByteArray; size: cint) {.
importc: "godot_pool_byte_array_resize".}
proc `[]=`*(self: var GodotPoolByteArray; idx: cint; data: uint8) {.
importc: "godot_pool_byte_array_set".}
proc `[]`*(self: GodotPoolByteArray; idx: cint): uint8 {.
noSideEffect,
importc: "godot_pool_byte_array_get".}
proc len*(self: GodotPoolByteArray): cint {.
noSideEffect,
importc: "godot_pool_byte_array_size".}
iterator items*(arr: GodotPoolByteArray): byte =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolByteArray): tuple[key: cint, val: byte] =
for i in 0..<arr.len:
yield (i, arr[i])
proc initGodotPoolIntArray*(dest: var GodotPoolIntArray) {.
importc: "godot_pool_int_array_new".}
proc initGodotPoolIntArray*(dest: var GodotPoolIntArray;
src: GodotPoolIntArray) {.
importc: "godot_pool_int_array_new_copy".}
proc initGodotPoolIntArray*(dest: var GodotPoolIntArray;
arr: GodotArray) {.
importc: "godot_pool_int_array_new_with_array".}
proc deinit*(self: var GodotPoolIntArray) {.
importc: "godot_pool_int_array_destroy".}
proc add*(self: var GodotPoolIntArray; data: cint) {.
importc: "godot_pool_int_array_append".}
proc addFirst*(self: var GodotPoolIntArray; data: cint) {.
importc: "godot_pool_int_array_push_back".}
proc add*(self: var GodotPoolIntArray; arr: GodotPoolIntArray) {.
importc: "godot_pool_int_array_append_array".}
proc insert*(self: var GodotPoolIntArray; idx: cint;
data: cint): Error {.
importc: "godot_pool_int_array_insert".}
proc delete*(self: var GodotPoolIntArray; idx: cint) {.
importc: "godot_pool_int_array_remove".}
proc reverse*(self: var GodotPoolIntArray) {.
importc: "godot_pool_int_array_invert".}
proc setLen*(self: var GodotPoolIntArray; size: cint) {.
importc: "godot_pool_int_array_resize".}
proc `[]=`*(self: var GodotPoolIntArray; idx: cint; data: cint) {.
importc: "godot_pool_int_array_set".}
proc `[]`*(self: GodotPoolIntArray; idx: cint): cint {.
noSideEffect,
importc: "godot_pool_int_array_get".}
proc len*(self: GodotPoolIntArray): cint {.
noSideEffect,
importc: "godot_pool_int_array_size".}
iterator items*(arr: GodotPoolIntArray): cint =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolIntArray): tuple[key: cint, val: cint] =
for i in 0..<arr.len:
yield (i, arr[i])
# Real
proc initGodotPoolRealArray*(dest: var GodotPoolRealArray) {.
importc: "godot_pool_real_array_new".}
proc initGodotPoolRealArray*(dest: var GodotPoolRealArray;
src: GodotPoolRealArray) {.
importc: "godot_pool_real_array_new_copy".}
proc initGodotPoolRealArray*(dest: var GodotPoolRealArray; arr: GodotArray) {.
importc: "godot_pool_real_array_new_with_array".}
proc deinit*(self: var GodotPoolRealArray) {.
importc: "godot_pool_real_array_destroy".}
proc add*(self: var GodotPoolRealArray; data: float32) {.
importc: "godot_pool_real_array_append".}
proc addFirst*(self: var GodotPoolRealArray; data: float32) {.
importc: "godot_pool_real_array_push_back".}
proc add*(self: var GodotPoolRealArray; arr: GodotPoolRealArray) {.
importc: "godot_pool_real_array_append_array".}
proc insert*(self: var GodotPoolRealArray;
idx: cint; data: float32): Error {.
importc: "godot_pool_real_array_insert".}
proc delete*(self: var GodotPoolRealArray; idx: cint) {.
importc: "godot_pool_real_array_remove".}
proc reverse*(self: var GodotPoolRealArray) {.
importc: "godot_pool_real_array_invert".}
proc setLen*(self: var GodotPoolRealArray; size: cint) {.
importc: "godot_pool_real_array_resize".}
proc `[]=`*(self: var GodotPoolRealArray; idx: cint; data: float32) {.
importc: "godot_pool_real_array_set".}
proc `[]`*(self: GodotPoolRealArray; idx: cint): float32 {.
noSideEffect,
importc: "godot_pool_real_array_get".}
proc len*(self: GodotPoolRealArray): cint {.
noSideEffect,
importc: "godot_pool_real_array_size".}
iterator items*(arr: GodotPoolRealArray): float32 =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolRealArray): tuple[key: cint, val: float32] =
for i in 0..<arr.len:
yield (i, arr[i])
# String
proc initGodotPoolStringArray*(dest: var GodotPoolStringArray) {.
importc: "godot_pool_string_array_new".}
proc initGodotPoolStringArray*(dest: var GodotPoolStringArray;
src: GodotPoolStringArray) {.
importc: "godot_pool_string_array_new_copy".}
proc initGodotPoolStringArray*(dest: var GodotPoolStringArray; arr: GodotArray) {.
importc: "godot_pool_string_array_new_with_array".}
proc deinit*(self: var GodotPoolStringArray) {.
importc: "godot_pool_string_array_destroy".}
proc initGodotPoolStringArray*(): GodotPoolStringArray {.inline.} =
initGodotPoolStringArray(result)
proc initGodotPoolStringArray*(arr: GodotArray): GodotPoolStringArray {.inline.} =
initGodotPoolStringArray(result, arr)
proc add*(self: var GodotPoolStringArray; data: GodotString) {.
importc: "godot_pool_string_array_append".}
proc addFirst*(self: var GodotPoolStringArray; data: GodotString) {.
importc: "godot_pool_string_array_push_back".}
proc add*(self: var GodotPoolStringArray; arr: GodotPoolStringArray) {.
importc: "godot_pool_string_array_append_array".}
proc insert*(self: var GodotPoolStringArray;
idx: cint; data: GodotString): Error {.
importc: "godot_pool_string_array_insert".}
proc delete*(self: var GodotPoolStringArray; idx: cint) {.
importc: "godot_pool_string_array_remove".}
proc reverse*(self: var GodotPoolStringArray) {.
importc: "godot_pool_string_array_invert".}
proc setLen*(self: var GodotPoolStringArray; size: cint) {.
importc: "godot_pool_string_array_resize".}
proc `[]=`*(self: var GodotPoolStringArray; idx: cint;
data: GodotString) {.
importc: "godot_pool_string_array_set".}
proc `[]`*(self: GodotPoolStringArray; idx: cint): GodotString {.
noSideEffect,
importc: "godot_pool_string_array_get".}
proc len*(self: GodotPoolStringArray): cint {.
noSideEffect,
importc: "godot_pool_string_array_size".}
iterator items*(arr: GodotPoolStringArray): GodotString =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolStringArray): tuple[key: cint, val: GodotString] =
for i in 0..<arr.len:
yield (i, arr[i])
# Vector2
proc initGodotPoolVector2Array*(dest: var GodotPoolVector2Array) {.
importc: "godot_pool_vector2_array_new".}
proc initGodotPoolVector2Array*(dest: var GodotPoolVector2Array;
src: GodotPoolVector2Array) {.
importc: "godot_pool_vector2_array_new_copy".}
proc initGodotPoolVector2Array*(dest: var GodotPoolVector2Array;
arr: GodotArray) {.
importc: "godot_pool_vector2_array_new_with_array".}
proc deinit*(self: var GodotPoolVector2Array) {.
importc: "godot_pool_vector2_array_destroy".}
proc initGodotPoolVector2Array*(): GodotPoolVector2Array {.inline.} =
initGodotPoolVector2Array(result)
proc initGodotPoolVector2Array*(arr: GodotArray): GodotPoolVector2Array {.inline.} =
initGodotPoolVector2Array(result, arr)
proc add*(self: var GodotPoolVector2Array; data: Vector2) {.
importc: "godot_pool_vector2_array_append".}
proc addFirst*(self: var GodotPoolVector2Array; data: Vector2) {.
importc: "godot_pool_vector2_array_push_back".}
proc add*(self: var GodotPoolVector2Array;
arr: GodotPoolVector2Array) {.
importc: "godot_pool_vector2_array_append_array".}
proc insert*(self: var GodotPoolVector2Array;
idx: cint; data: Vector2): Error {.
importc: "godot_pool_vector2_array_insert".}
proc delete*(self: var GodotPoolVector2Array; idx: cint) {.
importc: "godot_pool_vector2_array_remove".}
proc reverse*(self: var GodotPoolVector2Array) {.
importc: "godot_pool_vector2_array_invert".}
proc setLen*(self: var GodotPoolVector2Array; size: cint) {.
importc: "godot_pool_vector2_array_resize".}
proc `[]=`*(self: var GodotPoolVector2Array; idx: cint;
data: Vector2) {.
importc: "godot_pool_vector2_array_set".}
proc `[]`*(self: GodotPoolVector2Array; idx: cint): Vector2 {.
noSideEffect,
importc: "godot_pool_vector2_array_get".}
proc len*(self: GodotPoolVector2Array): cint {.
noSideEffect,
importc: "godot_pool_vector2_array_size".}
iterator items*(arr: GodotPoolVector2Array): Vector2 =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolVector2Array): tuple[key: cint, val: Vector2] =
for i in 0..<arr.len:
yield (i, arr[i])
# Vector3
proc initGodotPoolVector3Array*(dest: var GodotPoolVector3Array) {.
importc: "godot_pool_vector3_array_new".}
proc initGodotPoolVector3Array*(dest: var GodotPoolVector3Array;
src: GodotPoolVector3Array) {.
importc: "godot_pool_vector3_array_new_copy".}
proc initGodotPoolVector3Array*(dest: var GodotPoolVector3Array;
arr: GodotArray) {.
importc: "godot_pool_vector3_array_new_with_array".}
proc deinit*(self: var GodotPoolVector3Array) {.
importc: "godot_pool_vector3_array_destroy".}
proc initGodotPoolVector3Array*(): GodotPoolVector3Array {.inline.} =
initGodotPoolVector3Array(result)
proc initGodotPoolVector3Array*(arr: GodotArray):
GodotPoolVector3Array {.inline.} =
initGodotPoolVector3Array(result, arr)
proc add*(self: var GodotPoolVector3Array;
data: Vector3) {.
importc: "godot_pool_vector3_array_append".}
proc addFirst*(self: var GodotPoolVector3Array;
data: Vector3) {.
importc: "godot_pool_vector3_array_push_back".}
proc add*(self: var GodotPoolVector3Array;
arr: GodotPoolVector3Array) {.
importc: "godot_pool_vector3_array_append_array".}
proc insert*(self: var GodotPoolVector3Array;
idx: cint; data: Vector3): Error {.
importc: "godot_pool_vector3_array_insert".}
proc delete*(self: var GodotPoolVector3Array; idx: cint) {.
importc: "godot_pool_vector3_array_remove".}
proc reverse*(self: var GodotPoolVector3Array) {.
importc: "godot_pool_vector3_array_invert".}
proc setLen*(self: var GodotPoolVector3Array; size: cint) {.
importc: "godot_pool_vector3_array_resize".}
proc `[]=`*(self: var GodotPoolVector3Array;
idx: cint; data: Vector3) {.
importc: "godot_pool_vector3_array_set".}
proc `[]`*(self: GodotPoolVector3Array;
idx: cint): Vector3 {.
noSideEffect,
importc: "godot_pool_vector3_array_get".}
proc len*(self: GodotPoolVector3Array): cint {.
noSideEffect,
importc: "godot_pool_vector3_array_size".}
iterator items*(arr: GodotPoolVector3Array): Vector3 =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolVector3Array): tuple[key: cint, val: Vector3] =
for i in 0..<arr.len:
yield (i, arr[i])
# Color
proc initGodotPoolColorArray*(dest: var GodotPoolColorArray) {.
importc: "godot_pool_color_array_new".}
proc initGodotPoolColorArray*(dest: var GodotPoolColorArray;
src: GodotPoolColorArray) {.
importc: "godot_pool_color_array_new_copy".}
proc initGodotPoolColorArray*(dest: var GodotPoolColorArray; arr: GodotArray) {.
importc: "godot_pool_color_array_new_with_array".}
proc deinit*(self: var GodotPoolColorArray) {.
importc: "godot_pool_color_array_destroy".}
proc initGodotPoolColorArray*(): GodotPoolColorArray {.inline.} =
initGodotPoolColorArray(result)
proc initGodotPoolColorArray*(arr: GodotArray): GodotPoolColorArray {.inline.} =
initGodotPoolColorArray(result, arr)
proc add*(self: var GodotPoolColorArray; data: Color) {.
importc: "godot_pool_color_array_append".}
proc addFirst*(self: var GodotPoolColorArray; data: Color) {.
importc: "godot_pool_color_array_push_back".}
proc add*(self: var GodotPoolColorArray; arr: GodotPoolColorArray) {.
importc: "godot_pool_color_array_append_array".}
proc insert*(self: var GodotPoolColorArray;
idx: cint; data: Color): Error {.
importc: "godot_pool_color_array_insert".}
proc delete*(self: var GodotPoolColorArray; idx: cint) {.
importc: "godot_pool_color_array_remove".}
proc reverse*(self: var GodotPoolColorArray) {.
importc: "godot_pool_color_array_invert".}
proc setLen*(self: var GodotPoolColorArray; size: cint) {.
importc: "godot_pool_color_array_resize".}
proc `[]=`*(self: var GodotPoolColorArray; idx: cint;
data: Color) {.
importc: "godot_pool_color_array_set".}
proc `[]`*(self: GodotPoolColorArray; idx: cint): Color {.
noSideEffect,
importc: "godot_pool_color_array_get".}
proc len*(self: GodotPoolColorArray): cint {.
noSideEffect,
importc: "godot_pool_color_array_size".}
iterator items*(arr: GodotPoolColorArray): Color =
for i in 0..<arr.len:
yield arr[i]
iterator pairs*(arr: GodotPoolColorArray): tuple[key: cint, val: Color] =
for i in 0..<arr.len:
yield (i, arr[i])

20
godot/core/strings.nim → godot/internal/godotstrings.nim
View file

@ -1,15 +1,11 @@
# Copyright (c) 2017 Xored Software, Inc. # Copyright (c) 2017 Xored Software, Inc.
import godotbase
type type
GodotString* {.byref.} = object GodotString* {.byref.} = object
p: pointer p: pointer
proc initGodotString(dest: var GodotString) {. proc initGodotString(dest: var GodotString) {.
importc: "godot_string_new".} importc: "godot_string_new".}
proc initGodotString(dest: var GodotString; src: GodotString) {.
importc: "godot_string_new_copy".}
proc initGodotString(dest: var GodotString; contents: cstring; proc initGodotString(dest: var GodotString; contents: cstring;
size: cint) {. size: cint) {.
importc: "godot_string_new_data".} importc: "godot_string_new_data".}
@ -34,11 +30,6 @@ proc `&`*(self, b: GodotString): GodotString {.
importc: "godot_string_operator_plus".} importc: "godot_string_operator_plus".}
proc deinit*(self: var GodotString) {.importc: "godot_string_destroy".} proc deinit*(self: var GodotString) {.importc: "godot_string_destroy".}
proc `=destroy`(self: GodotString) {.inline.} =
unsafeAddr(self).deinit()
proc `=`(self: var GodotString, other: GodotString) {.inline.} =
initGodotString(self, other)
proc `$`*(self: GodotString): string = proc `$`*(self: GodotString): string =
## Converts the ``GodotString`` into Nim string ## Converts the ``GodotString`` into Nim string
@ -61,14 +52,3 @@ proc toGodotString*(s: cstring): GodotString {.inline.} =
initGodotString(result) initGodotString(result)
else: else:
initGodotString(result, s, cint(s.len + 1)) initGodotString(result, s, cint(s.len + 1))
proc godotPrint(message: GodotString) {.
importc: "godot_print".}
proc print*(message: string) {.inline.} =
let s = message.toGodotString()
godotPrint(s)
proc print*(message: cstring) {.inline.} =
let s = message.toGodotString()
godotPrint(s)

190
godot/internal/godotvariants.nim Normal file
View file

@ -0,0 +1,190 @@
# Copyright 2017 Xored Software, Inc.
type
VariantType* {.size: sizeof(cint), pure.} = enum
Nil, ## atomic types
Bool,
Int,
Real,
String,
# math types
Vector2, ## 5
Rect2,
Vector3,
Transform2D,
Plane,
Quat, ## 10
Rect3,
Basis,
Transform, ## misc types
Color,
NodePath, ## 15
RID,
Object,
Dictionary,
Array, ## 20
# arrays
PoolByteArray,
PoolIntArray,
PoolRealArray,
PoolStringArray,
PoolVector2Array, ## 25
PoolVector3Array,
PoolColorArray
VariantCallErrorType* {.size: sizeof(cint), pure.} = enum
OK,
InvalidMethod,
InvalidArgument,
TooManyArguments,
TooFewArguments,
InstanceIsNull
VariantCallError* = object
error*: VariantCallErrorType
argument*: cint
expected*: VariantType
import godotinternaltypes, godotpoolarrays, godotstrings, godotnodepaths,
godotdictionaries
import "../core/vector2.nim", "../core/rect2.nim",
"../core/vector3.nim", "../core/transform2d.nim", "../core/planes.nim",
"../core/quats.nim", "../core/rect3.nim", "../core/basis.nim",
"../core/transforms.nim", "../core/colors.nim", "../core/rids.nim",
"../core/rect2.nim"
proc getType*(p: GodotVariant): VariantType {.
importc: "godot_variant_get_type".}
proc initGodotVariant*(dest: var GodotVariant) {.
importc: "godot_variant_new_nil".}
proc initGodotVariant*(dest: var GodotVariant, src: GodotVariant) {.
importc: "godot_variant_new_copy".}
proc initGodotVariant*(dest: var GodotVariant; b: bool) {.
importc: "godot_variant_new_bool".}
proc initGodotVariant*(dest: var GodotVariant; i: uint64) {.
importc: "godot_variant_new_uint".}
proc initGodotVariant*(dest: var GodotVariant; i: int64) {.
importc: "godot_variant_new_int".}
proc initGodotVariant*(dest: var GodotVariant; r: cdouble) {.
importc: "godot_variant_new_real".}
proc initGodotVariant*(dest: var GodotVariant; s: GodotString) {.
importc: "godot_variant_new_string".}
proc initGodotVariant*(dest: var GodotVariant; v2: Vector2) {.
importc: "godot_variant_new_vector2".}
proc initGodotVariant*(dest: var GodotVariant; rect2: Rect2) {.
importc: "godot_variant_new_rect2".}
proc initGodotVariant*(dest: var GodotVariant; v3: Vector3) {.
importc: "godot_variant_new_vector3".}
proc initGodotVariant*(dest: var GodotVariant; t2d: Transform2D) {.
importc: "godot_variant_new_transform2d".}
proc initGodotVariant*(dest: var GodotVariant; plane: Plane) {.
importc: "godot_variant_new_plane".}
proc initGodotVariant*(dest: var GodotVariant; quat: Quat) {.
importc: "godot_variant_new_quat".}
proc initGodotVariant*(dest: var GodotVariant; rect3: Rect3) {.
importc: "godot_variant_new_rect3".}
proc initGodotVariant*(dest: var GodotVariant; basis: Basis) {.
importc: "godot_variant_new_basis".}
proc initGodotVariant*(dest: var GodotVariant; trans: Transform) {.
importc: "godot_variant_new_transform".}
proc initGodotVariant*(dest: var GodotVariant; color: Color) {.
importc: "godot_variant_new_color".}
proc initGodotVariant*(dest: var GodotVariant; nodePath: GodotNodePath) {.
importc: "godot_variant_new_node_path".}
proc initGodotVariant*(dest: var GodotVariant; rid: RID) {.
importc: "godot_variant_new_rid".}
proc initGodotVariant*(dest: var GodotVariant; obj: ptr GodotObject) {.
importc: "godot_variant_new_object".}
proc initGodotVariant*(dest: var GodotVariant; arr: GodotArray) {.
importc: "godot_variant_new_array".}
proc initGodotVariant*(dest: var GodotVariant; pba: GodotPoolByteArray) {.
importc: "godot_variant_new_pool_byte_array".}
proc initGodotVariant*(dest: var GodotVariant; pia: GodotPoolIntArray) {.
importc: "godot_variant_new_pool_int_array".}
proc initGodotVariant*(dest: var GodotVariant; pra: GodotPoolRealArray) {.
importc: "godot_variant_new_pool_real_array".}
proc initGodotVariant*(dest: var GodotVariant; psa: GodotPoolStringArray) {.
importc: "godot_variant_new_pool_string_array".}
proc initGodotVariant*(dest: var GodotVariant; pv2a: GodotPoolVector2Array) {.
importc: "godot_variant_new_pool_vector2_array".}
proc initGodotVariant*(dest: var GodotVariant; pv3a: GodotPoolVector3Array) {.
importc: "godot_variant_new_pool_vector3_array".}
proc initGodotVariant*(dest: var GodotVariant; pca: GodotPoolColorArray) {.
importc: "godot_variant_new_pool_color_array".}
proc initGodotVariant*(dest: var GodotVariant; dict: GodotDictionary) {.
importc: "godot_variant_new_dictionary".}
proc deinit*(v: var GodotVariant) {.importc: "godot_variant_destroy".}
proc asBool*(self: GodotVariant): bool {.
importc: "godot_variant_as_bool".}
proc asUInt*(self: GodotVariant): uint64 {.
importc: "godot_variant_as_uint".}
proc asInt*(self: GodotVariant): int64 {.
importc: "godot_variant_as_int".}
proc asReal*(self: GodotVariant): cdouble {.
importc: "godot_variant_as_real".}
proc asGodotString*(self: GodotVariant): GodotString {.
importc: "godot_variant_as_string".}
proc asVector2*(self: GodotVariant): Vector2 {.
importc: "godot_variant_as_vector2".}
proc asRect2*(self: GodotVariant): Rect2 {.
importc: "godot_variant_as_rect2".}
proc asVector3*(self: GodotVariant): Vector3 {.
importc: "godot_variant_as_vector3".}
proc asTransform2D*(self: GodotVariant): Transform2D {.
importc: "godot_variant_as_transform2d".}
proc asPlane*(self: GodotVariant): Plane {.
importc: "godot_variant_as_plane".}
proc asQuat*(self: GodotVariant): Quat {.
importc: "godot_variant_as_quat".}
proc asRect3*(self: GodotVariant): Rect3 {.
importc: "godot_variant_as_rect3".}
proc asBasis*(self: GodotVariant): Basis {.
importc: "godot_variant_as_basis".}
proc asTransform*(self: GodotVariant): Transform {.
importc: "godot_variant_as_transform".}
proc asColor*(self: GodotVariant): Color {.
importc: "godot_variant_as_color".}
proc asNodePath*(self: GodotVariant): GodotNodePath {.
importc: "godot_variant_as_node_path".}
proc asRID*(self: GodotVariant): RID {.
importc: "godot_variant_as_rid".}
proc asGodotObject*(self: GodotVariant): ptr GodotObject {.
importc: "godot_variant_as_object".}
proc asGodotArray*(self: GodotVariant): GodotArray {.
importc: "godot_variant_as_array".}
proc asGodotPoolByteArray*(self: GodotVariant): GodotPoolByteArray {.
importc: "godot_variant_as_pool_byte_array".}
proc asGodotPoolIntArray*(self: GodotVariant): GodotPoolIntArray {.
importc: "godot_variant_as_pool_int_array".}
proc asGodotPoolRealArray*(self: GodotVariant): GodotPoolRealArray {.
importc: "godot_variant_as_pool_real_array".}
proc asGodotPoolStringArray*(self: GodotVariant): GodotPoolStringArray {.
importc: "godot_variant_as_pool_string_array".}
proc asGodotPoolVector2Array*(self: GodotVariant): GodotPoolVector2Array {.
importc: "godot_variant_as_pool_vector2_array".}
proc asGodotPoolVector3Array*(self: GodotVariant): GodotPoolVector3Array {.
importc: "godot_variant_as_pool_vector3_array".}
proc asGodotPoolColorArray*(self: GodotVariant): GodotPoolColorArray {.
importc: "godot_variant_as_pool_color_array".}
proc asGodotDictionary*(self: GodotVariant): GodotDictionary {.
importc: "godot_variant_as_dictionary".}
proc call*(self: GodotVariant; meth: GodotString;
args: var array[128, GodotVariant]; argCount: cint;
error: var VariantCallError): GodotVariant {.
importc: "godot_variant_call".}
proc hasMethod*(self: GodotVariant; meth: GodotString): bool {.
importc: "godot_variant_has_method".}
proc `==`*(self, other: GodotVariant): bool {.
importc: "godot_variant_operator_equal".}
proc `<`*(self, other: GodotVariant): bool {.
importc: "godot_variant_operator_less".}
proc hashCompare*(self, other: GodotVariant): bool {.
importc: "godot_variant_hash_compare".}
proc booleanize*(self: GodotVariant; isValid: var bool): bool {.
importc: "godot_variant_booleanize".}

56
godot/nim/godotmacros.nim
View file

@ -1,8 +1,8 @@
# Copyright 2017 Xored Software, Inc. # Copyright 2017 Xored Software, Inc.
import macros, tables, typetraits import macros, tables, typetraits
import "../core/godotcore.nim" import "../godotinternal.nim", "../internal/godotvariants.nim"
import godotnim import godotnim, "../core/variants.nim"
type type
VarDecl = ref object VarDecl = ref object
@ -64,18 +64,6 @@ iterator pragmas(node: NimNode):
elif node[index].kind == nnkIdent: elif node[index].kind == nnkIdent:
yield (node[index].ident, nil, index) yield (node[index].ident, nil, index)
proc hasPragma(statement: NimNode, pname: string): bool =
## Checks if the pragma is present in the `statement`
if not (RoutineNodes.contains(statement.kind) or
statement.kind == nnkPragmaExpr):
return false
var pragmas = if RoutineNodes.contains(statement.kind): statement.pragma()
else: statement[1]
let pnameIdent = !pname
for ident, val, i in pragmas(pragmas):
if ident == pnameIdent:
return true
proc removePragma(statement: NimNode, pname: string): bool = proc removePragma(statement: NimNode, pname: string): bool =
## Removes the pragma from the node and returns whether pragma was removed ## Removes the pragma from the node and returns whether pragma was removed
if not (RoutineNodes.contains(statement.kind) or if not (RoutineNodes.contains(statement.kind) or
@ -205,7 +193,9 @@ macro invokeVarArgs(procIdent, objIdent;
## error(...) ## error(...)
template conv(procLit, argT, argSeq, idx, argIdent, errIdent) = template conv(procLit, argT, argSeq, idx, argIdent, errIdent) =
let (argIdent, errIdent) = godotToNim[argT](argSeq[idx]) let v = newVariant(argSeq[idx])
v.markNoDeinit() # args should be destroyed externally
let (argIdent, errIdent) = godotToNim[argT](v)
if errIdent != ConversionResult.OK: if errIdent != ConversionResult.OK:
let errorKind = if errIdent == ConversionResult.TypeError: "a type error" let errorKind = if errIdent == ConversionResult.TypeError: "a type error"
else: "a range error" else: "a range error"
@ -215,6 +205,14 @@ macro invokeVarArgs(procIdent, objIdent;
" of Godot type " & $argSeq[idx].getType()) " of Godot type " & $argSeq[idx].getType())
return return
# these help to avoid exporting internal modules
# thanks to closed symbol binding
template initGodotVariantCall(result) =
initGodotVariant(result)
template initGodotVariantCall(result, src) =
initGodotVariant(result, src)
result = newNimNode(nnkCaseStmt) result = newNimNode(nnkCaseStmt)
result.add(numArgsIdent) result.add(numArgsIdent)
for i in minArgs..maxArgs: for i in minArgs..maxArgs:
@ -231,12 +229,13 @@ macro invokeVarArgs(procIdent, objIdent;
argSeqIdent, idx, argIdent, errIdent))) argSeqIdent, idx, argIdent, errIdent)))
invocation.add(argIdent) invocation.add(argIdent)
if hasReturnValue: if hasReturnValue:
branchBody.add(newNimNode(nnkAsgn).add(ident("result"), let theCall = newNimNode(nnkBracketExpr).add(newNimNode(nnkDotExpr).add(
newCall("toGodot", invocation))) newCall("toGodot", newCall("newVariant", invocation)),
ident("godotVariant")))
branchBody.add(getAst(initGodotVariantCall(ident("result"), theCall)))
else: else:
branchBody.add(invocation) branchBody.add(invocation)
branchBody.add(newNimNode(nnkAsgn).add(ident("result"), branchBody.add(getAst(initGodotVariantCall(ident("result"))))
newCall("variant")))
branch.add(branchBody) branch.add(branchBody)
result.add(branch) result.add(branch)
@ -306,8 +305,10 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit,
hintIdent, usageIdent, hasDefaultValue, hintIdent, usageIdent, hasDefaultValue,
defaultValueNode) = defaultValueNode) =
proc setFuncIdent(obj: ptr GodotObject, methData: pointer, proc setFuncIdent(obj: ptr GodotObject, methData: pointer,
nimPtr: pointer, val: Variant) {.noconv.} = nimPtr: pointer, val: GodotVariant) {.noconv.} =
let (nimVal, err) = godotToNim[propTypeIdent](val) let variant = newVariant(val)
variant.markNoDeinit()
let (nimVal, err) = godotToNim[propTypeIdent](variant)
case err: case err:
of ConversionResult.OK: of ConversionResult.OK:
cast[classNameIdent](nimPtr).propNameIdent = nimVal cast[classNameIdent](nimPtr).propNameIdent = nimVal
@ -321,8 +322,10 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit,
printError(errStr) printError(errStr)
proc getFuncIdent(obj: ptr GodotObject, methData: pointer, proc getFuncIdent(obj: ptr GodotObject, methData: pointer,
nimPtr: pointer): Variant {.noconv.} = nimPtr: pointer): GodotVariant {.noconv.} =
result = nimToGodot(cast[classNameIdent](nimPtr).propNameIdent) let variant = nimToGodot(cast[classNameIdent](nimPtr).propNameIdent)
variant.markNoDeinit()
result = variant.godotVariant[]
let setFunc = GodotPropertySetFunc( let setFunc = GodotPropertySetFunc(
setFunc: setFuncIdent setFunc: setFuncIdent
@ -436,8 +439,8 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
argTypes, methFuncIdent, hasReturnValue) = argTypes, methFuncIdent, hasReturnValue) =
proc methFuncIdent(obj: ptr GodotObject, methodData: pointer, proc methFuncIdent(obj: ptr GodotObject, methodData: pointer,
userData: pointer, numArgs: cint, userData: pointer, numArgs: cint,
args: var ptr array[MAX_ARG_COUNT, Variant]): args: var ptr array[MAX_ARG_COUNT, GodotVariant]):
Variant {.noconv.} = GodotVariant {.noconv.} =
let self = cast[classNameIdent](userData) let self = cast[classNameIdent](userData)
when defined(release): when defined(release):
invokeVarArgs(methodNameIdent, self, minArgs, maxArgs, numArgs, invokeVarArgs(methodNameIdent, self, minArgs, maxArgs, numArgs,
@ -448,8 +451,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
args, argTypes, hasReturnValue) args, argTypes, hasReturnValue)
except: except:
let ex = getCurrentException() let ex = getCurrentException()
printError("Unhandled Nim exception (" & printError("Unhandled Nim exception (" & $ex.name & "): " &
$ex.name & "): " &
ex.msg & "\n" & ex.getStackTrace()) ex.msg & "\n" & ex.getStackTrace())
let meth = GodotInstanceMethod( let meth = GodotInstanceMethod(

100
godot/nim/godotnim.nim
View file

@ -1,13 +1,14 @@
# Copyright 2017 Xored Software, Inc. # Copyright 2017 Xored Software, Inc.
import tables, typetraits, macros import tables, typetraits, macros
import "../core/godotbase.nim", "../core/godotcore.nim" import "../core/godotbase.nim"
import "../core/strings.nim", "../core/vector2.nim", "../core/rect2.nim", import "../core/vector2.nim", "../core/rect2.nim",
"../core/vector3.nim", "../core/transform2d.nim", "../core/vector3.nim", "../core/transform2d.nim",
"../core/plane.nim", "../core/quat.nim", "../core/rect3.nim", "../core/planes.nim", "../core/quats.nim", "../core/rect3.nim",
"../core/basis.nim", "../core/transform.nim", "../core/color.nim", "../core/basis.nim", "../core/transforms.nim", "../core/colors.nim",
"../core/nodepath.nim", "../core/rid.nim", "../core/dictionary.nim", "../core/nodepaths.nim", "../core/rids.nim", "../core/dictionaries.nim",
"../core/arrays.nim", "../core/poolarray.nim", "../core/variant.nim" "../core/arrays.nim", "../core/poolarrays.nim", "../core/variants.nim"
import "../godotinternal.nim"
## Definition of NimGodotObject and converters for built-in types. ## Definition of NimGodotObject and converters for built-in types.
@ -48,6 +49,24 @@ type
isNative: bool isNative: bool
isRef: bool isRef: bool
template printWarning*(warn: typed) =
let (filename, line) = instantiationInfo()
godotPrintWarning(cstring($warn), nil, cstring(filename), line.cint)
template printError*(err: typed) =
let (filename, line) = instantiationInfo()
godotPrintError(cstring($err), nil, cstring(filename), line.cint)
proc print*(message: string) {.inline.} =
var s = message.toGodotString()
godotPrint(s)
s.deinit()
proc print*(message: cstring) {.inline.} =
var s = message.toGodotString()
godotPrint(s)
s.deinit()
var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo] var classRegistry {.threadvar.}: TableRef[cstring, ObjectInfo]
static: static:
@ -55,16 +74,8 @@ static:
var nativeClasses {.compileTime.} = newSeq[string]() var nativeClasses {.compileTime.} = newSeq[string]()
var refClasses* {.compileTime.} = newSeq[string]() var refClasses* {.compileTime.} = newSeq[string]()
var getClassMethodBind {.threadvar.}: ptr GodotMethodBind proc getClassName*(o: NimGodotObject): string =
proc getClassName*(o: ptr GodotObject): string = o.godotObject.getClassName()
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]
var unreferenceMethodBind {.threadvar.}: ptr GodotMethodBind var unreferenceMethodBind {.threadvar.}: ptr GodotMethodBind
proc unreference(o: ptr GodotObject): bool = proc unreference(o: ptr GodotObject): bool =
@ -176,6 +187,15 @@ proc asNimGodotObject*[T: NimGodotObject](godotObject: ptr GodotObject): T =
result = newNimGodotObject[T]( result = newNimGodotObject[T](
godotObject, cstring(godotObject.getClassName())) godotObject, cstring(godotObject.getClassName()))
proc newVariant*(obj: NimGodotObject): Variant {.inline.} =
newVariant(obj.godotObject)
proc asObject*[T: NimGodotObject](v: Variant): T {.inline.} =
asNimGodotObject[T](v.asGodotObject())
proc asObject*(v: Variant, T: typedesc[NimGodotObject]): T {.inline.} =
asNimGodotObject[T](v.asGodotObject())
proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T = proc `as`*[T: NimGodotObject](obj: NimGodotObject, t: typedesc[T]): T =
## Converts the ``obj`` into the specified type. ## Converts the ``obj`` into the specified type.
## Returns ``nil`` if the conversion cannot be performed ## Returns ``nil`` if the conversion cannot be performed
@ -250,7 +270,7 @@ proc newConversionError*(err: ConversionResult): ref ValueError =
result = newException(ValueError, msg) result = newException(ValueError, msg)
proc removeGodotObject*(nimObj: NimGodotObject) = proc removeGodotObject*(nimObj: NimGodotObject) {.inline.} =
## Used from destructor ## Used from destructor
nimObj.godotObject = nil nimObj.godotObject = nil
@ -269,12 +289,12 @@ proc godotVariantType*(T: typedesc[NimGodotObject]): VariantType {.inline.} =
VariantType.Object VariantType.Object
proc toGodot*(self: NimGodotObject): Variant {.inline.} = proc toGodot*(self: NimGodotObject): Variant {.inline.} =
variant(self.godotObject) newVariant(self.godotObject)
proc fromGodot*[T: NimGodotObject](self: var T, proc fromGodot*[T: NimGodotObject](self: var T,
val: Variant): ConversionResult = val: Variant): ConversionResult =
if val.getType() == VariantType.Object: if val.getType() == VariantType.Object:
let objPtr = val.asObject() let objPtr = val.asGodotObject()
self = asNimGodotObject[T](objPtr) self = asNimGodotObject[T](objPtr)
if self.isNil: if self.isNil:
result = ConversionResult.TypeError result = ConversionResult.TypeError
@ -287,19 +307,21 @@ proc godotVariantType*(T: typedesc[enum]): VariantType {.inline.} =
VariantType.Int VariantType.Int
proc toGodot*[T: enum](self: T): Variant {.inline.} = proc toGodot*[T: enum](self: T): Variant {.inline.} =
variant(int64(ord(self))) newVariant(int64(ord(self)))
proc fromGodot*[T: enum](self: var T, val: Variant): ConversionResult = proc fromGodot*[T: enum](self: var T,
val: Variant): ConversionResult {.inline.} =
if val.getType() == VariantType.Int: if val.getType() == VariantType.Int:
self = T(val.asInt()) self = T(val.asInt())
else: else:
result = ConversionResult.TypeError result = ConversionResult.TypeError
proc toGodot*(self: Variant): Variant {.inline.} = proc toGodot*(self: Variant): Variant {.inline.} =
result = self self
proc fromGodot*(self: var Variant, val: Variant): ConversionResult {.inline.} = proc fromGodot*(self: var Variant,
self = val val: Variant): ConversionResult {.inline.} =
self = newVariant(val)
proc godotVariantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} = proc godotVariantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} =
when T is SomeSignedInt or T is SomeUnsignedInt: when T is SomeSignedInt or T is SomeUnsignedInt:
@ -330,12 +352,12 @@ proc godotVariantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} =
VariantType.Transform VariantType.Transform
elif T is Color: elif T is Color:
VariantType.Color VariantType.Color
elif T is NodePath:
VariantType.NodePath
elif T is RID: elif T is RID:
VariantType.RID VariantType.RID
elif T is GodotObject: elif T is ptr GodotObject:
VariantType.Object VariantType.Object
elif T is NodePath:
VariantType.NodePath
elif T is Dictionary: elif T is Dictionary:
VariantType.Dictionary VariantType.Dictionary
elif T is Array: elif T is Array:
@ -358,7 +380,7 @@ proc godotVariantType*(T: typedesc[SomeGodotOrNum]): VariantType {.inline.} =
VariantType.Nil VariantType.Nil
proc toGodot*[T: SomeGodotOrNum](val: T): Variant {.inline.} = proc toGodot*[T: SomeGodotOrNum](val: T): Variant {.inline.} =
result = variant(val) newVariant(val)
proc fromGodot*[T: SomeSignedInt or SomeUnsignedInt]( proc fromGodot*[T: SomeSignedInt or SomeUnsignedInt](
self: var T, val: Variant): ConversionResult = self: var T, val: Variant): ConversionResult =
@ -376,7 +398,7 @@ proc fromGodot*[T: SomeSignedInt or SomeUnsignedInt](
proc fromGodot*[T: SomeFloat](self: var T, val: Variant): ConversionResult = proc fromGodot*[T: SomeFloat](self: var T, val: Variant): ConversionResult =
if val.getType() == VariantType.Real: if val.getType() == VariantType.Real:
self = val.asReal() self = T(val.asReal())
elif val.getType() == VariantType.Int: elif val.getType() == VariantType.Int:
self = T(val.asInt()) self = T(val.asInt())
else: else:
@ -441,13 +463,15 @@ proc godotVariantType*(T: typedesc[string]): VariantType {.inline.} =
VariantType.String VariantType.String
proc toGodot*(s: string): Variant {.inline.} = proc toGodot*(s: string): Variant {.inline.} =
variant(s.toGodotString()) newVariant(s)
proc fromGodot*(s: var string, val: Variant): ConversionResult = proc fromGodot*(s: var string, val: Variant): ConversionResult =
if val.getType() != VariantType.String: if val.getType() == VariantType.String:
result = ConversionResult.TypeError s = val.asString()
elif val.getType() == VariantType.Nil:
s = nil
else: else:
s = $val.asGodotString() result = ConversionResult.TypeError
proc godotVariantType*(T: typedesc[seq]): VariantType = proc godotVariantType*(T: typedesc[seq]): VariantType =
VariantType.Array VariantType.Array
@ -456,11 +480,11 @@ proc godotVariantType*(T: typedesc[array]): VariantType =
VariantType.Array VariantType.Array
proc toGodot*[T](s: openarray[T]): Variant = proc toGodot*[T](s: openarray[T]): Variant =
var arr = initArray() var arr = newArray()
mixin toGodot mixin toGodot
for item in s: for item in s:
arr.add(toGodot(item)) arr.add(toGodot(item))
result = variant(arr) result = newVariant(arr)
proc fromGodot*[T](s: var seq[T], val: Variant): ConversionResult = proc fromGodot*[T](s: var seq[T], val: Variant): ConversionResult =
if val.getType() != VariantType.Array: if val.getType() != VariantType.Array:
@ -492,11 +516,11 @@ proc godotVariantType*(T: typedesc[Table|TableRef]): VariantType {.inline.} =
VariantType.Dictionary VariantType.Dictionary
proc toGodot*[T: Table or TableRef](t: T): Variant = proc toGodot*[T: Table or TableRef](t: T): Variant =
var dict = initDictionary() var dict = newDictionary()
mixin toGodot mixin toGodot
for k, v in t.pairs(): for k, v in t.pairs():
dict[toGodot(k)] = toGodot(v) dict[toGodot(k)] = toGodot(v)
result = variant(dict) result = newVariant(dict)
proc fromGodot*[T: Table or TableRef](t: var T, val: Variant): ConversionResult = proc fromGodot*[T: Table or TableRef](t: var T, val: Variant): ConversionResult =
if val.getType() != VariantType.Dictionary: if val.getType() != VariantType.Dictionary:
@ -563,7 +587,7 @@ proc godot_gdnative_init(options: ptr GodotNativeInitOptions) {.
proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {. proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {.
cdecl, exportc, dynlib.} = cdecl, exportc, dynlib.} =
deallocHeap(runFinalizers = false, allowGcAfterwards = false) deallocHeap(runFinalizers = not options[].inEditor, allowGcAfterwards = false)
proc godot_nativescript_thread_enter() {. proc godot_nativescript_thread_enter() {.
cdecl, exportc, dynlib.} = cdecl, exportc, dynlib.} =

2
godot/nimruntime.nim
View file

@ -4,7 +4,7 @@ import asyncdispatch
import godot, node import godot, node
gdobj NimRuntime of Node: gdobj NimRuntime of Node:
method process*(delta: float32) = method process*(delta: float64) =
if asyncdispatch.hasPendingOperations(): if asyncdispatch.hasPendingOperations():
poll(0) poll(0)
GC_step(2000, false, 0) GC_step(2000, false, 0)