More pool array features: subarray, mitems, mpairs
This commit is contained in:
Ruslan Mustakov
parent
d11856377e
commit
be6f01e3b7
5 changed files with 559 additions and 92 deletions
|
|
@ -1,4 +1,4 @@
|
|||
version = "0.7.6"
|
||||
version = "0.7.7"
|
||||
author = "Xored Software, Inc."
|
||||
description = "Godot Engine bindings"
|
||||
license = "MIT"
|
||||
|
|
|
|||
|
|
@ -48,6 +48,12 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
|
|||
proc len*(self: T): int {.inline.} =
|
||||
self.fieldName.len.int
|
||||
|
||||
proc subarray*(self: T, idxFrom, idxTo: int): T {.inline.} =
|
||||
## Indexes are inclusive, negative values count from the end of the array.
|
||||
assert(idxFrom >= low(cint) and idxFrom <= high(cint) and
|
||||
idxTo >= low(cint) and idxTo <= high(cint))
|
||||
newProcName(self.fieldName.subarray(idxFrom.cint, idxTo.cint))
|
||||
|
||||
when not noData:
|
||||
proc add*(self: T; data: DataT) {.inline.} =
|
||||
self.fieldName.add(data)
|
||||
|
|
@ -62,12 +68,20 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
|
|||
self.fieldName[idx.cint]
|
||||
|
||||
iterator items*(arr: T): DataT =
|
||||
for i in 0..<arr.len:
|
||||
yield arr[i]
|
||||
for item in arr.fieldName.items:
|
||||
yield item
|
||||
|
||||
iterator pairs*(arr: T): tuple[key: int, val: DataT] =
|
||||
for i in 0..<arr.len:
|
||||
yield (i, arr[i])
|
||||
for pair in arr.fieldName.pairs:
|
||||
yield (pair[0].int, pair[1])
|
||||
|
||||
iterator mitems*(arr: T): var DataT =
|
||||
for item in arr.fieldName.mitems:
|
||||
yield item
|
||||
|
||||
iterator mpairs*(arr: T): tuple[key: int, val: var DataT] =
|
||||
for pair in arr.fieldName.mpairs:
|
||||
yield (pair[0].int, pair[1])
|
||||
|
||||
definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8,
|
||||
godotPoolByteArray, newPoolByteArray,
|
||||
|
|
@ -75,7 +89,7 @@ definePoolArrayBase(PoolByteArray, GodotPoolByteArray, uint8,
|
|||
definePoolArrayBase(PoolIntArray, GodotPoolIntArray, cint,
|
||||
godotPoolIntArray, newPoolIntArray,
|
||||
initGodotPoolIntArray)
|
||||
definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float64,
|
||||
definePoolArrayBase(PoolRealArray, GodotPoolRealArray, float32,
|
||||
godotPoolRealArray, newPoolRealArray,
|
||||
initGodotPoolRealArray)
|
||||
definePoolArrayBase(PoolVector2Array, GodotPoolVector2Array, Vector2,
|
||||
|
|
@ -99,7 +113,7 @@ definePoolArray(PoolByteArray, GodotPoolByteArray, uint8,
|
|||
definePoolArray(PoolIntArray, GodotPoolIntArray, cint,
|
||||
godotPoolIntArray, newPoolIntArray,
|
||||
initGodotPoolIntArray)
|
||||
definePoolArray(PoolRealArray, GodotPoolRealArray, float64,
|
||||
definePoolArray(PoolRealArray, GodotPoolRealArray, float32,
|
||||
godotPoolRealArray, newPoolRealArray,
|
||||
initGodotPoolRealArray)
|
||||
definePoolArray(PoolVector2Array, GodotPoolVector2Array, Vector2,
|
||||
|
|
|
|||
|
|
@ -347,8 +347,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayResize: proc (self: var GodotPoolByteArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayRead: pointer
|
||||
poolByteArrayWrite: pointer
|
||||
poolByteArrayRead: proc (self: GodotPoolByteArray): ptr GodotPoolByteArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWrite: proc (self: var GodotPoolByteArray): ptr GodotPoolByteArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArraySet: proc (self: var GodotPoolByteArray, idx: cint, data: byte)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayGet: proc (self: GodotPoolByteArray, idx: cint): byte
|
||||
|
|
@ -384,8 +386,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayResize: proc (self: var GodotPoolIntArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayRead: pointer
|
||||
poolIntArrayWrite: pointer
|
||||
poolIntArrayRead: proc (self: GodotPoolIntArray): ptr GodotPoolIntArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWrite: proc (self: var GodotPoolIntArray): ptr GodotPoolIntArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArraySet: proc (self: var GodotPoolIntArray, idx: cint, data: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayGet: proc (self: GodotPoolIntArray, idx: cint): cint
|
||||
|
|
@ -423,8 +427,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayResize: proc (self: var GodotPoolRealArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayRead: pointer
|
||||
poolRealArrayWrite: pointer
|
||||
poolRealArrayRead: proc (self: GodotPoolRealArray): ptr GodotPoolRealArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWrite: proc (self: var GodotPoolRealArray): ptr GodotPoolRealArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArraySet: proc (self: var GodotPoolRealArray, idx: cint,
|
||||
data: float32)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -471,8 +477,10 @@ type
|
|||
poolStringArrayResize: proc (self: var GodotPoolStringArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [],
|
||||
locks: 0.}
|
||||
poolStringArrayRead: pointer
|
||||
poolStringArrayWrite: pointer
|
||||
poolStringArrayRead: proc (self: GodotPoolStringArray): ptr GodotPoolStringArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWrite: proc (self: var GodotPoolStringArray): ptr GodotPoolStringArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArraySet: proc (self: var GodotPoolStringArray, idx: cint,
|
||||
data: GodotString)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -519,8 +527,10 @@ type
|
|||
poolVector2ArrayResize: proc (self: var GodotPoolVector2Array, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [],
|
||||
locks: 0.}
|
||||
poolVector2ArrayRead: pointer
|
||||
poolVector2ArrayWrite: pointer
|
||||
poolVector2ArrayRead: proc (self: GodotPoolVector2Array): ptr GodotPoolVector2ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWrite: proc (self: var GodotPoolVector2Array): ptr GodotPoolVector2ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArraySet: proc (self: var GodotPoolVector2Array, idx: cint,
|
||||
data: Vector2)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -566,8 +576,10 @@ type
|
|||
poolVector3ArrayResize: proc (self: var GodotPoolVector3Array,
|
||||
size: cint) {.noconv, raises: [], gcsafe,
|
||||
tags: [], locks: 0.}
|
||||
poolVector3ArrayRead: pointer
|
||||
poolVector3ArrayWrite: pointer
|
||||
poolVector3ArrayRead: proc (self: GodotPoolVector3Array): ptr GodotPoolVector3ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWrite: proc (self: var GodotPoolVector3Array): ptr GodotPoolVector3ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArraySet: proc (self: var GodotPoolVector3Array, idx: cint,
|
||||
data: Vector3) {.noconv, raises: [], gcsafe,
|
||||
tags: [], locks: 0.}
|
||||
|
|
@ -609,8 +621,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayResize: proc (self: var GodotPoolColorArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayRead: pointer
|
||||
poolColorArrayWrite: pointer
|
||||
poolColorArrayRead: proc (self: GodotPoolColorArray): ptr GodotPoolColorArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWrite: proc (self: var GodotPoolColorArray): ptr GodotPoolColorArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArraySet: proc (self: var GodotPoolColorArray, idx: cint,
|
||||
data: Color)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -622,65 +636,133 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [],
|
||||
locks: 0.}
|
||||
|
||||
# Pool Array Read Access API
|
||||
# Pool Array Read/Write Access API
|
||||
|
||||
poolByteArrayReadAccessCopy: pointer
|
||||
poolByteArrayReadAccessPtr: pointer
|
||||
poolByteArrayReadAccessOperatorAssign: pointer
|
||||
poolByteArrayReadAccessDestroy: pointer
|
||||
poolIntArrayReadAccessCopy: pointer
|
||||
poolIntArrayReadAccessPtr: pointer
|
||||
poolIntArrayReadAccessOperatorAssign: pointer
|
||||
poolIntArrayReadAccessDestroy: pointer
|
||||
poolRealArrayReadAccessCopy: pointer
|
||||
poolRealArrayReadAccessPtr: pointer
|
||||
poolRealArrayReadAccessOperatorAssign: pointer
|
||||
poolRealArrayReadAccessDestroy: pointer
|
||||
poolStringArrayReadAccessCopy: pointer
|
||||
poolStringArrayReadAccessPtr: pointer
|
||||
poolStringArrayReadAccessOperatorAssign: pointer
|
||||
poolStringArrayReadAccessDestroy: pointer
|
||||
poolVector2ArrayReadAccessCopy: pointer
|
||||
poolVector2ArrayReadAccessPtr: pointer
|
||||
poolVector2ArrayReadAccessOperatorAssign: pointer
|
||||
poolVector2ArrayReadAccessDestroy: pointer
|
||||
poolVector3ArrayReadAccessCopy: pointer
|
||||
poolVector3ArrayReadAccessPtr: pointer
|
||||
poolVector3ArrayReadAccessOperatorAssign: pointer
|
||||
poolVector3ArrayReadAccessDestroy: pointer
|
||||
poolColorArrayReadAccessCopy: pointer
|
||||
poolColorArrayReadAccessPtr: pointer
|
||||
poolColorArrayReadAccessOperatorAssign: pointer
|
||||
poolColorArrayReadAccessDestroy: pointer
|
||||
poolByteArrayReadAccessCopy: proc (self: ptr GodotPoolByteArrayReadAccess): ptr GodotPoolByteArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayReadAccessPtr: proc (self: ptr GodotPoolByteArrayReadAccess): ptr byte
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolByteArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayReadAccessDestroy: proc (self: ptr GodotPoolByteArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolByteArrayWriteAccessCopy: pointer
|
||||
poolByteArrayWriteAccessPtr: pointer
|
||||
poolByteArrayWriteAccessOperatorAssign: pointer
|
||||
poolByteArrayWriteAccessDestroy: pointer
|
||||
poolIntArrayWriteAccessCopy: pointer
|
||||
poolIntArrayWriteAccessPtr: pointer
|
||||
poolIntArrayWriteAccessOperatorAssign: pointer
|
||||
poolIntArrayWriteAccessDestroy: pointer
|
||||
poolRealArrayWriteAccessCopy: pointer
|
||||
poolRealArrayWriteAccessPtr: pointer
|
||||
poolRealArrayWriteAccessOperatorAssign: pointer
|
||||
poolRealArrayWriteAccessDestroy: pointer
|
||||
poolStringArrayWriteAccessCopy: pointer
|
||||
poolStringArrayWriteAccessPtr: pointer
|
||||
poolStringArrayWriteAccessOperatorAssign: pointer
|
||||
poolStringArrayWriteAccessDestroy: pointer
|
||||
poolVector2ArrayWriteAccessCopy: pointer
|
||||
poolVector2ArrayWriteAccessPtr: pointer
|
||||
poolVector2ArrayWriteAccessOperatorAssign: pointer
|
||||
poolVector2ArrayWriteAccessDestroy: pointer
|
||||
poolVector3ArrayWriteAccessCopy: pointer
|
||||
poolVector3ArrayWriteAccessPtr: pointer
|
||||
poolVector3ArrayWriteAccessOperatorAssign: pointer
|
||||
poolVector3ArrayWriteAccessDestroy: pointer
|
||||
poolColorArrayWriteAccessCopy: pointer
|
||||
poolColorArrayWriteAccessPtr: pointer
|
||||
poolColorArrayWriteAccessOperatorAssign: pointer
|
||||
poolColorArrayWriteAccessDestroy: pointer
|
||||
poolIntArrayReadAccessCopy: proc (self: ptr GodotPoolIntArrayReadAccess): ptr GodotPoolIntArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayReadAccessPtr: proc (self: ptr GodotPoolIntArrayReadAccess): ptr cint
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolIntArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayReadAccessDestroy: proc (self: ptr GodotPoolIntArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolRealArrayReadAccessCopy: proc (self: ptr GodotPoolRealArrayReadAccess): ptr GodotPoolRealArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayReadAccessPtr: proc (self: ptr GodotPoolRealArrayReadAccess): ptr float32
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolRealArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayReadAccessDestroy: proc (self: ptr GodotPoolRealArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolStringArrayReadAccessCopy: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotPoolStringArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayReadAccessPtr: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotString
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolStringArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayReadAccessDestroy: proc (self: ptr GodotPoolStringArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector2ArrayReadAccessCopy: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr GodotPoolVector2ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayReadAccessPtr: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr Vector2
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolVector2ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayReadAccessDestroy: proc (self: ptr GodotPoolVector2ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector3ArrayReadAccessCopy: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr GodotPoolVector3ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayReadAccessPtr: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr Vector3
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolVector3ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayReadAccessDestroy: proc (self: ptr GodotPoolVector3ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolColorArrayReadAccessCopy: proc (self: ptr GodotPoolColorArrayReadAccess): ptr GodotPoolColorArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayReadAccessPtr: proc (self: ptr GodotPoolColorArrayReadAccess): ptr Color
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayReadAccessOperatorAssign: proc (self, other: ptr GodotPoolColorArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayReadAccessDestroy: proc (self: ptr GodotPoolColorArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolByteArrayWriteAccessCopy: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr GodotPoolByteArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWriteAccessPtr: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr byte
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolByteArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWriteAccessDestroy: proc (self: ptr GodotPoolByteArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolIntArrayWriteAccessCopy: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr GodotPoolIntArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWriteAccessPtr: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr cint
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolIntArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWriteAccessDestroy: proc (self: ptr GodotPoolIntArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolRealArrayWriteAccessCopy: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr GodotPoolRealArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWriteAccessPtr: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr float32
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolRealArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWriteAccessDestroy: proc (self: ptr GodotPoolRealArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolStringArrayWriteAccessCopy: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotPoolStringArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWriteAccessPtr: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotString
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolStringArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWriteAccessDestroy: proc (self: ptr GodotPoolStringArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector2ArrayWriteAccessCopy: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr GodotPoolVector2ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWriteAccessPtr: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr Vector2
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolVector2ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWriteAccessDestroy: proc (self: ptr GodotPoolVector2ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector3ArrayWriteAccessCopy: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr GodotPoolVector3ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWriteAccessPtr: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr Vector3
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolVector3ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWriteAccessDestroy: proc (self: ptr GodotPoolVector3ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolColorArrayWriteAccessCopy: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr GodotPoolColorArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWriteAccessPtr: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr Color
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWriteAccessOperatorAssign: proc (self, other: ptr GodotPoolColorArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWriteAccessDestroy: proc (self: ptr GodotPoolColorArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
# Array API
|
||||
arrayNew: proc (dest: var GodotArray)
|
||||
|
|
@ -1707,6 +1789,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayResize*: proc (self: var GodotPoolByteArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayRead*: proc (self: GodotPoolByteArray): ptr GodotPoolByteArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWrite*: proc (self: var GodotPoolByteArray): ptr GodotPoolByteArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArraySet*: proc (self: var GodotPoolByteArray, idx: cint, data: byte)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayGet*: proc (self: GodotPoolByteArray, idx: cint): byte
|
||||
|
|
@ -1742,6 +1828,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayResize*: proc (self: var GodotPoolIntArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayRead*: proc (self: GodotPoolIntArray): ptr GodotPoolIntArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWrite*: proc (self: var GodotPoolIntArray): ptr GodotPoolIntArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArraySet*: proc (self: var GodotPoolIntArray, idx: cint, data: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayGet*: proc (self: GodotPoolIntArray, idx: cint): cint
|
||||
|
|
@ -1778,6 +1868,10 @@ type
|
|||
poolRealArrayRemove*: proc (self: var GodotPoolRealArray, idx: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayResize*: proc (self: var GodotPoolRealArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayRead*: proc (self: GodotPoolRealArray): ptr GodotPoolRealArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWrite*: proc (self: var GodotPoolRealArray): ptr GodotPoolRealArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArraySet*: proc (self: var GodotPoolRealArray, idx: cint,
|
||||
data: float32)
|
||||
|
|
@ -1825,6 +1919,10 @@ type
|
|||
poolStringArrayResize*: proc (self: var GodotPoolStringArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [],
|
||||
locks: 0.}
|
||||
poolStringArrayRead*: proc (self: GodotPoolStringArray): ptr GodotPoolStringArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWrite*: proc (self: var GodotPoolStringArray): ptr GodotPoolStringArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArraySet*: proc (self: var GodotPoolStringArray, idx: cint,
|
||||
data: GodotString)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -1871,6 +1969,10 @@ type
|
|||
poolVector2ArrayResize*: proc (self: var GodotPoolVector2Array, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [],
|
||||
locks: 0.}
|
||||
poolVector2ArrayRead*: proc (self: GodotPoolVector2Array): ptr GodotPoolVector2ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWrite*: proc (self: var GodotPoolVector2Array): ptr GodotPoolVector2ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArraySet*: proc (self: var GodotPoolVector2Array, idx: cint,
|
||||
data: Vector2)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -1916,6 +2018,10 @@ type
|
|||
poolVector3ArrayResize*: proc (self: var GodotPoolVector3Array,
|
||||
size: cint) {.noconv, raises: [], gcsafe,
|
||||
tags: [], locks: 0.}
|
||||
poolVector3ArrayRead*: proc (self: GodotPoolVector3Array): ptr GodotPoolVector3ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWrite*: proc (self: var GodotPoolVector3Array): ptr GodotPoolVector3ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArraySet*: proc (self: var GodotPoolVector3Array, idx: cint,
|
||||
data: Vector3) {.noconv, raises: [], gcsafe,
|
||||
tags: [], locks: 0.}
|
||||
|
|
@ -1957,6 +2063,10 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayResize*: proc (self: var GodotPoolColorArray, size: cint)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayRead*: proc (self: GodotPoolColorArray): ptr GodotPoolColorArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWrite*: proc (self: var GodotPoolColorArray): ptr GodotPoolColorArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArraySet*: proc (self: var GodotPoolColorArray, idx: cint,
|
||||
data: Color)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -1968,6 +2078,134 @@ type
|
|||
{.noconv, raises: [], gcsafe, tags: [],
|
||||
locks: 0.}
|
||||
|
||||
# Pool Array Read/Write Access API
|
||||
|
||||
poolByteArrayReadAccessCopy*: proc (self: ptr GodotPoolByteArrayReadAccess): ptr GodotPoolByteArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayReadAccessPtr*: proc (self: ptr GodotPoolByteArrayReadAccess): ptr byte
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolByteArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayReadAccessDestroy*: proc (self: ptr GodotPoolByteArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolIntArrayReadAccessCopy*: proc (self: ptr GodotPoolIntArrayReadAccess): ptr GodotPoolIntArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayReadAccessPtr*: proc (self: ptr GodotPoolIntArrayReadAccess): ptr cint
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolIntArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayReadAccessDestroy*: proc (self: ptr GodotPoolIntArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolRealArrayReadAccessCopy*: proc (self: ptr GodotPoolRealArrayReadAccess): ptr GodotPoolRealArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayReadAccessPtr*: proc (self: ptr GodotPoolRealArrayReadAccess): ptr float32
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolRealArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayReadAccessDestroy*: proc (self: ptr GodotPoolRealArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolStringArrayReadAccessCopy*: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotPoolStringArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayReadAccessPtr*: proc (self: ptr GodotPoolStringArrayReadAccess): ptr GodotString
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolStringArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayReadAccessDestroy*: proc (self: ptr GodotPoolStringArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector2ArrayReadAccessCopy*: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr GodotPoolVector2ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayReadAccessPtr*: proc (self: ptr GodotPoolVector2ArrayReadAccess): ptr Vector2
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector2ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayReadAccessDestroy*: proc (self: ptr GodotPoolVector2ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector3ArrayReadAccessCopy*: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr GodotPoolVector3ArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayReadAccessPtr*: proc (self: ptr GodotPoolVector3ArrayReadAccess): ptr Vector3
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector3ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayReadAccessDestroy*: proc (self: ptr GodotPoolVector3ArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolColorArrayReadAccessCopy*: proc (self: ptr GodotPoolColorArrayReadAccess): ptr GodotPoolColorArrayReadAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayReadAccessPtr*: proc (self: ptr GodotPoolColorArrayReadAccess): ptr Color
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayReadAccessOperatorAssign*: proc (self, other: ptr GodotPoolColorArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayReadAccessDestroy*: proc (self: ptr GodotPoolColorArrayReadAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolByteArrayWriteAccessCopy*: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr GodotPoolByteArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWriteAccessPtr*: proc (self: ptr GodotPoolByteArrayWriteAccess): ptr byte
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolByteArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolByteArrayWriteAccessDestroy*: proc (self: ptr GodotPoolByteArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolIntArrayWriteAccessCopy*: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr GodotPoolIntArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWriteAccessPtr*: proc (self: ptr GodotPoolIntArrayWriteAccess): ptr cint
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolIntArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolIntArrayWriteAccessDestroy*: proc (self: ptr GodotPoolIntArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolRealArrayWriteAccessCopy*: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr GodotPoolRealArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWriteAccessPtr*: proc (self: ptr GodotPoolRealArrayWriteAccess): ptr float32
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolRealArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolRealArrayWriteAccessDestroy*: proc (self: ptr GodotPoolRealArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolStringArrayWriteAccessCopy*: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotPoolStringArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWriteAccessPtr*: proc (self: ptr GodotPoolStringArrayWriteAccess): ptr GodotString
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolStringArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolStringArrayWriteAccessDestroy*: proc (self: ptr GodotPoolStringArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector2ArrayWriteAccessCopy*: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr GodotPoolVector2ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWriteAccessPtr*: proc (self: ptr GodotPoolVector2ArrayWriteAccess): ptr Vector2
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector2ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector2ArrayWriteAccessDestroy*: proc (self: ptr GodotPoolVector2ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolVector3ArrayWriteAccessCopy*: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr GodotPoolVector3ArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWriteAccessPtr*: proc (self: ptr GodotPoolVector3ArrayWriteAccess): ptr Vector3
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolVector3ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolVector3ArrayWriteAccessDestroy*: proc (self: ptr GodotPoolVector3ArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
poolColorArrayWriteAccessCopy*: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr GodotPoolColorArrayWriteAccess
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWriteAccessPtr*: proc (self: ptr GodotPoolColorArrayWriteAccess): ptr Color
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWriteAccessOperatorAssign*: proc (self, other: ptr GodotPoolColorArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
poolColorArrayWriteAccessDestroy*: proc (self: ptr GodotPoolColorArrayWriteAccess)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
||||
# Array API
|
||||
arrayNew*: proc (dest: var GodotArray)
|
||||
{.noconv, raises: [], gcsafe, tags: [], locks: 0.}
|
||||
|
|
@ -2780,6 +3018,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolByteArrayPushBack
|
||||
poolByteArrayRemove
|
||||
poolByteArrayResize
|
||||
poolByteArrayRead
|
||||
poolByteArrayWrite
|
||||
poolByteArraySet
|
||||
poolByteArrayGet
|
||||
poolByteArraySize
|
||||
|
|
@ -2796,6 +3036,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolIntArrayPushBack
|
||||
poolIntArrayRemove
|
||||
poolIntArrayResize
|
||||
poolIntArrayRead
|
||||
poolIntArrayWrite
|
||||
poolIntArraySet
|
||||
poolIntArrayGet
|
||||
poolIntArraySize
|
||||
|
|
@ -2812,6 +3054,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolRealArrayPushBack
|
||||
poolRealArrayRemove
|
||||
poolRealArrayResize
|
||||
poolRealArrayRead
|
||||
poolRealArrayWrite
|
||||
poolRealArraySet
|
||||
poolRealArrayGet
|
||||
poolRealArraySize
|
||||
|
|
@ -2828,6 +3072,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolStringArrayPushBack
|
||||
poolStringArrayRemove
|
||||
poolStringArrayResize
|
||||
poolStringArrayRead
|
||||
poolStringArrayWrite
|
||||
poolStringArraySet
|
||||
poolStringArrayGet
|
||||
poolStringArraySize
|
||||
|
|
@ -2845,6 +3091,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolVector2ArrayPushBack
|
||||
poolVector2ArrayRemove
|
||||
poolVector2ArrayResize
|
||||
poolVector2ArrayRead
|
||||
poolVector2ArrayWrite
|
||||
poolVector2ArraySet
|
||||
poolVector2ArrayGet
|
||||
poolVector2ArraySize
|
||||
|
|
@ -2861,6 +3109,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolVector3ArrayPushBack
|
||||
poolVector3ArrayRemove
|
||||
poolVector3ArrayResize
|
||||
poolVector3ArrayRead
|
||||
poolVector3ArrayWrite
|
||||
poolVector3ArraySet
|
||||
poolVector3ArrayGet
|
||||
poolVector3ArraySize
|
||||
|
|
@ -2877,6 +3127,8 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
poolColorArrayPushBack
|
||||
poolColorArrayRemove
|
||||
poolColorArrayResize
|
||||
poolColorArrayRead
|
||||
poolColorArrayWrite
|
||||
poolColorArraySet
|
||||
poolColorArrayGet
|
||||
poolColorArraySize
|
||||
|
|
@ -2922,6 +3174,78 @@ proc setGDNativeAPI*(apiStruct: pointer, initOptions: ptr GDNativeInitOptions) =
|
|||
arrayBSearchCustom
|
||||
arrayDestroy
|
||||
|
||||
# Pool Array Read/Write Access API
|
||||
|
||||
poolByteArrayReadAccessCopy
|
||||
poolByteArrayReadAccessPtr
|
||||
poolByteArrayReadAccessOperatorAssign
|
||||
poolByteArrayReadAccessDestroy
|
||||
|
||||
poolIntArrayReadAccessCopy
|
||||
poolIntArrayReadAccessPtr
|
||||
poolIntArrayReadAccessOperatorAssign
|
||||
poolIntArrayReadAccessDestroy
|
||||
|
||||
poolRealArrayReadAccessCopy
|
||||
poolRealArrayReadAccessPtr
|
||||
poolRealArrayReadAccessOperatorAssign
|
||||
poolRealArrayReadAccessDestroy
|
||||
|
||||
poolStringArrayReadAccessCopy
|
||||
poolStringArrayReadAccessPtr
|
||||
poolStringArrayReadAccessOperatorAssign
|
||||
poolStringArrayReadAccessDestroy
|
||||
|
||||
poolVector2ArrayReadAccessCopy
|
||||
poolVector2ArrayReadAccessPtr
|
||||
poolVector2ArrayReadAccessOperatorAssign
|
||||
poolVector2ArrayReadAccessDestroy
|
||||
|
||||
poolVector3ArrayReadAccessCopy
|
||||
poolVector3ArrayReadAccessPtr
|
||||
poolVector3ArrayReadAccessOperatorAssign
|
||||
poolVector3ArrayReadAccessDestroy
|
||||
|
||||
poolColorArrayReadAccessCopy
|
||||
poolColorArrayReadAccessPtr
|
||||
poolColorArrayReadAccessOperatorAssign
|
||||
poolColorArrayReadAccessDestroy
|
||||
|
||||
poolByteArrayWriteAccessCopy
|
||||
poolByteArrayWriteAccessPtr
|
||||
poolByteArrayWriteAccessOperatorAssign
|
||||
poolByteArrayWriteAccessDestroy
|
||||
|
||||
poolIntArrayWriteAccessCopy
|
||||
poolIntArrayWriteAccessPtr
|
||||
poolIntArrayWriteAccessOperatorAssign
|
||||
poolIntArrayWriteAccessDestroy
|
||||
|
||||
poolRealArrayWriteAccessCopy
|
||||
poolRealArrayWriteAccessPtr
|
||||
poolRealArrayWriteAccessOperatorAssign
|
||||
poolRealArrayWriteAccessDestroy
|
||||
|
||||
poolStringArrayWriteAccessCopy
|
||||
poolStringArrayWriteAccessPtr
|
||||
poolStringArrayWriteAccessOperatorAssign
|
||||
poolStringArrayWriteAccessDestroy
|
||||
|
||||
poolVector2ArrayWriteAccessCopy
|
||||
poolVector2ArrayWriteAccessPtr
|
||||
poolVector2ArrayWriteAccessOperatorAssign
|
||||
poolVector2ArrayWriteAccessDestroy
|
||||
|
||||
poolVector3ArrayWriteAccessCopy
|
||||
poolVector3ArrayWriteAccessPtr
|
||||
poolVector3ArrayWriteAccessOperatorAssign
|
||||
poolVector3ArrayWriteAccessDestroy
|
||||
|
||||
poolColorArrayWriteAccessCopy
|
||||
poolColorArrayWriteAccessPtr
|
||||
poolColorArrayWriteAccessOperatorAssign
|
||||
poolColorArrayWriteAccessDestroy
|
||||
|
||||
# Dictionary API
|
||||
dictionaryNew
|
||||
dictionaryNewCopy
|
||||
|
|
|
|||
|
|
@ -16,18 +16,52 @@ type
|
|||
|
||||
GodotPoolByteArray* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolByteArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolByteArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotPoolIntArray* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolIntArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolIntArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotPoolRealArray* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolRealArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolRealArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotPoolStringArray* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolStringArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolStringArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotPoolVector2Array* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolVector2ArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolVector2ArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotPoolVector3Array* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolVector3ArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolVector3ArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotPoolColorArray* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
GodotPoolColorArrayReadAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
GodotPoolColorArrayWriteAccess* {.byref.} = object
|
||||
data: array[1, byte]
|
||||
|
||||
GodotString* {.byref.} = object
|
||||
data: array[sizeof(int), byte]
|
||||
|
|
|
|||
|
|
@ -3,11 +3,16 @@
|
|||
import godotinternaltypes, gdnativeapi
|
||||
import core.godotcoretypes
|
||||
|
||||
proc offset[T](p: ptr T, offset: int): ptr T {.inline.} =
|
||||
cast[ptr T](cast[ByteAddress](p) +% (offset * sizeof(T)))
|
||||
|
||||
template genPoolArrayAPI(ArrayT, initIdent, DataT,
|
||||
newProc, newCopyProc, newWithArrayProc, appendProc,
|
||||
appendArrayProc, insertProc, invertProc, pushBackProc,
|
||||
removeProc, resizeProc, setProc, getProc, sizeProc,
|
||||
destroyProc) =
|
||||
destroyProc, readProc, writeProc,
|
||||
readAccessPtrProc, writeAccessPtrProc,
|
||||
readAccessDestroyProc, writeAccessDestroyProc) =
|
||||
proc initIdent*(dest: var ArrayT) {.inline.} =
|
||||
getGDNativeAPI().newProc(dest)
|
||||
|
||||
|
|
@ -48,13 +53,61 @@ template genPoolArrayAPI(ArrayT, initIdent, DataT,
|
|||
proc len*(self: ArrayT): cint {.inline.} =
|
||||
getGDNativeAPI().sizeProc(self)
|
||||
|
||||
iterator items*(arr: ArrayT): DataT =
|
||||
for i in 0.cint..<arr.len:
|
||||
yield arr[i]
|
||||
iterator items*(self: ArrayT): DataT =
|
||||
let readAccess = getGDNativeAPI().readProc(self)
|
||||
let readPtr = getGDNativeAPI().readAccessPtrProc(readAccess)
|
||||
for i in 0.cint..<self.len:
|
||||
yield readPtr.offset(i)[]
|
||||
getGDNativeAPI().readAccessDestroyProc(readAccess)
|
||||
|
||||
iterator pairs*(arr: ArrayT): tuple[key: cint, val: DataT] =
|
||||
for i in 0.cint..<arr.len:
|
||||
yield (i, arr[i])
|
||||
iterator mitems*(self: var ArrayT): var DataT =
|
||||
let writeAccess = getGDNativeAPI().writeProc(self)
|
||||
let writePtr = getGDNativeAPI().writeAccessPtrProc(writeAccess)
|
||||
for i in 0.cint..<self.len:
|
||||
yield writePtr.offset(i)[]
|
||||
getGDNativeAPI().writeAccessDestroyProc(writeAccess)
|
||||
|
||||
iterator pairs*(self: ArrayT): tuple[key: cint, val: DataT] =
|
||||
let readAccess = getGDNativeAPI().readProc(self)
|
||||
let readPtr = getGDNativeAPI().readAccessPtrProc(readAccess)
|
||||
for i in 0.cint..<self.len:
|
||||
yield (i, readPtr.offset(i)[])
|
||||
getGDNativeAPI().readAccessDestroyProc(readAccess)
|
||||
|
||||
iterator mpairs*(self: var ArrayT): tuple[key: cint, val: var DataT] =
|
||||
let writeAccess = getGDNativeAPI().writeProc(self)
|
||||
let writePtr = getGDNativeAPI().writeAccessPtrProc(writeAccess)
|
||||
for i in 0.cint..<self.len:
|
||||
yield (i, writePtr.offset(i)[])
|
||||
getGDNativeAPI().writeAccessDestroyProc(writeAccess)
|
||||
|
||||
proc subarray*(self: ArrayT, idxFrom, idxTo: cint): ArrayT =
|
||||
## Indexes are inclusive, negative values count from the end of the array.
|
||||
let ownLen = self.len
|
||||
var actualIdxFrom = if idxFrom < 0: idxFrom + ownLen
|
||||
else: idxFrom
|
||||
var actualIdxTo = if idxTo < 0: idxTo + ownLen
|
||||
else: idxTo
|
||||
|
||||
initIdent(result)
|
||||
if actualIdxFrom < 0 or actualIdxFrom >= ownLen:
|
||||
let (file, line) = instantiationInfo()
|
||||
getGDNativeAPI().printError(
|
||||
cstring"Invalid subarray begin index", cstring"subarray", file, line.cint)
|
||||
return
|
||||
if actualIdxTo < 0 or actualIdxTo >= ownLen:
|
||||
let (file, line) = instantiationInfo()
|
||||
getGDNativeAPI().printError(
|
||||
cstring"Invalid subarray end index", cstring"subarray", file, line.cint)
|
||||
return
|
||||
let span = actualIdxTo - actualIdxFrom + 1
|
||||
result.setLen(span)
|
||||
let readAccess = getGDNativeAPI().readProc(self)
|
||||
let writeAccess = getGDNativeAPI().writeProc(result)
|
||||
let readPtr = getGDNativeAPI().readAccessPtrProc(readAccess).offset(actualIdxFrom)
|
||||
copyMem(getGDNativeAPI().writeAccessPtrProc(writeAccess), readPtr, span)
|
||||
getGDNativeAPI().readAccessDestroyProc(readAccess)
|
||||
getGDNativeAPI().writeAccessDestroyProc(writeAccess)
|
||||
|
||||
genPoolArrayAPI(GodotPoolByteArray, initGodotPoolByteArray, byte,
|
||||
poolByteArrayNew,
|
||||
|
|
@ -70,7 +123,13 @@ genPoolArrayAPI(GodotPoolByteArray, initGodotPoolByteArray, byte,
|
|||
poolByteArraySet,
|
||||
poolByteArrayGet,
|
||||
poolByteArraySize,
|
||||
poolByteArrayDestroy)
|
||||
poolByteArrayDestroy,
|
||||
poolByteArrayRead,
|
||||
poolByteArrayWrite,
|
||||
poolByteArrayReadAccessPtr,
|
||||
poolByteArrayWriteAccessPtr,
|
||||
poolByteArrayReadAccessDestroy,
|
||||
poolByteArrayWriteAccessDestroy)
|
||||
|
||||
genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint,
|
||||
poolIntArrayNew,
|
||||
|
|
@ -86,7 +145,13 @@ genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint,
|
|||
poolIntArraySet,
|
||||
poolIntArrayGet,
|
||||
poolIntArraySize,
|
||||
poolIntArrayDestroy)
|
||||
poolIntArrayDestroy,
|
||||
poolIntArrayRead,
|
||||
poolIntArrayWrite,
|
||||
poolIntArrayReadAccessPtr,
|
||||
poolIntArrayWriteAccessPtr,
|
||||
poolIntArrayReadAccessDestroy,
|
||||
poolIntArrayWriteAccessDestroy)
|
||||
|
||||
genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32,
|
||||
poolRealArrayNew,
|
||||
|
|
@ -102,7 +167,13 @@ genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32,
|
|||
poolRealArraySet,
|
||||
poolRealArrayGet,
|
||||
poolRealArraySize,
|
||||
poolRealArrayDestroy)
|
||||
poolRealArrayDestroy,
|
||||
poolRealArrayRead,
|
||||
poolRealArrayWrite,
|
||||
poolRealArrayReadAccessPtr,
|
||||
poolRealArrayWriteAccessPtr,
|
||||
poolRealArrayReadAccessDestroy,
|
||||
poolRealArrayWriteAccessDestroy)
|
||||
|
||||
genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString,
|
||||
poolStringArrayNew,
|
||||
|
|
@ -118,7 +189,13 @@ genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString,
|
|||
poolStringArraySet,
|
||||
poolStringArrayGet,
|
||||
poolStringArraySize,
|
||||
poolStringArrayDestroy)
|
||||
poolStringArrayDestroy,
|
||||
poolStringArrayRead,
|
||||
poolStringArrayWrite,
|
||||
poolStringArrayReadAccessPtr,
|
||||
poolStringArrayWriteAccessPtr,
|
||||
poolStringArrayReadAccessDestroy,
|
||||
poolStringArrayWriteAccessDestroy)
|
||||
|
||||
genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2,
|
||||
poolVector2ArrayNew,
|
||||
|
|
@ -134,7 +211,13 @@ genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2,
|
|||
poolVector2ArraySet,
|
||||
poolVector2ArrayGet,
|
||||
poolVector2ArraySize,
|
||||
poolVector2ArrayDestroy)
|
||||
poolVector2ArrayDestroy,
|
||||
poolVector2ArrayRead,
|
||||
poolVector2ArrayWrite,
|
||||
poolVector2ArrayReadAccessPtr,
|
||||
poolVector2ArrayWriteAccessPtr,
|
||||
poolVector2ArrayReadAccessDestroy,
|
||||
poolVector2ArrayWriteAccessDestroy)
|
||||
|
||||
genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3,
|
||||
poolVector3ArrayNew,
|
||||
|
|
@ -150,7 +233,13 @@ genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3,
|
|||
poolVector3ArraySet,
|
||||
poolVector3ArrayGet,
|
||||
poolVector3ArraySize,
|
||||
poolVector3ArrayDestroy)
|
||||
poolVector3ArrayDestroy,
|
||||
poolVector3ArrayRead,
|
||||
poolVector3ArrayWrite,
|
||||
poolVector3ArrayReadAccessPtr,
|
||||
poolVector3ArrayWriteAccessPtr,
|
||||
poolVector3ArrayReadAccessDestroy,
|
||||
poolVector3ArrayWriteAccessDestroy)
|
||||
|
||||
genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color,
|
||||
poolColorArrayNew,
|
||||
|
|
@ -166,4 +255,10 @@ genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color,
|
|||
poolColorArraySet,
|
||||
poolColorArrayGet,
|
||||
poolColorArraySize,
|
||||
poolColorArrayDestroy)
|
||||
poolColorArrayDestroy,
|
||||
poolColorArrayRead,
|
||||
poolColorArrayWrite,
|
||||
poolColorArrayReadAccessPtr,
|
||||
poolColorArrayWriteAccessPtr,
|
||||
poolColorArrayReadAccessDestroy,
|
||||
poolColorArrayWriteAccessDestroy)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue