374 lines
15 KiB
Nim
374 lines
15 KiB
Nim
# Copyright (c) 2017 Xored Software, Inc.
|
|
|
|
type
|
|
GodotPoolByteArray* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
GodotPoolIntArray* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
GodotPoolRealArray* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
GodotPoolStringArray* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
GodotPoolVector2Array* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
GodotPoolVector3Array* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
GodotPoolColorArray* {.byref.} = object
|
|
data: array[sizeof(int), byte]
|
|
|
|
import godotstrings, godotarrays
|
|
import core.godotbase, core.colors, core.vector2, core.vector3
|
|
|
|
# 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])
|