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

Use GDNative API struct

Browse source
This commit is contained in:
Ruslan Mustakov 2017-10-04 23:41:15 +07:00
commit b62db02d8f
32 changed files with 2846 additions and 1535 deletions
Download patch file Download diff file Expand all files Collapse all files

6
godot/core/arrays.nim
View file

@ -1,7 +1,7 @@
# Copyright 2017 Xored Software, Inc.
import hashes
import internal.godotarrays
import internal.godotinternaltypes, internal.godotarrays
type
Array* = ref object
@ -125,8 +125,8 @@ proc delete*(self: var Array; idx: int) {.inline.} =
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 rfind*(self: Array; what: Variant; fromIdx: int): int {.inline.} =
self.godotArray.rfind(what.godotVariant[], fromIdx.cint).int
proc len*(self: Array): int {.inline.} =
self.godotArray.len.int

5
godot/core/basis.nim
View file

@ -2,10 +2,7 @@
import math
import godotbase, vector3, quats
type
Basis* {.byref.} = object
elements*: array[3, Vector3]
import godotcoretypes
proc setCells*(basis: var Basis, xx, xy, xz, yx, yy, yz, zx, zy, zz: float32) =
basis.elements[0].x = xx

45
godot/core/colors.nim
View file

@ -1,11 +1,6 @@
# Copyright (c) 2017 Xored Software, Inc.
type
Color* {.byref.} = object
r*: float32
g*: float32
b*: float32
a*: float32
import godotcoretypes, gdnativeapi
proc initColor*(r, g, b: float32; a: float32 = 1.0'f32): Color {.inline.} =
Color(
@ -19,12 +14,14 @@ proc initColor*(): Color {.inline.} =
## Initializes black color with 1.0 alpha
initColor(0, 0, 0)
proc h*(self: Color): float32 {.
importc: "godot_color_get_h".}
proc s*(self: Color): float32 {.
importc: "godot_color_get_s".}
proc v*(self: Color): float32 {.
importc: "godot_color_get_v".}
proc h*(self: Color): float32 {.inline.} =
getGDNativeAPI().colorGetH(self)
proc s*(self: Color): float32 {.inline.} =
getGDNativeAPI().colorGetS(self)
proc v*(self: Color): float32 {.inline.} =
getGDNativeAPI().colorGetV(self)
proc `$`*(self: Color): string {.inline.} =
result = newStringOfCap(50)
@ -58,16 +55,20 @@ proc toARGB32*(self: Color): uint32 {.inline.} =
result = (result shl 8) or uint8(self.g * 255)
result = (result shl 8) or uint8(self.b * 255)
proc gray*(self: Color): float32 {.
importc: "godot_color_gray".}
proc inverted*(self: Color): Color {.
importc: "godot_color_inverted".}
proc contrasted*(self: Color): Color {.
importc: "godot_color_contrasted".}
proc lerp*(self: Color; b: Color; t: float32): Color {.
importc: "godot_color_linear_interpolate".}
proc blend*(self: Color; over: Color): Color {.
importc: "godot_color_blend".}
proc gray*(self: Color): float32 {.inline.} =
getGDNativeAPI().colorGray(self)
proc inverted*(self: Color): Color {.inline.} =
getGDNativeAPI().colorInverted(self)
proc contrasted*(self: Color): Color {.inline.} =
getGDNativeAPI().colorContrasted(self)
proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} =
getGDNativeAPI().colorLinearInterpolate(self, b, t)
proc blend*(self: Color; over: Color): Color {.inline.} =
getGDNativeAPI().colorBlend(self, over)
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

4
godot/core/dictionaries.nim
View file

@ -1,8 +1,8 @@
# Copyright 2017 Xored Software, Inc.
import hashes
import internal.godotstrings, internal.godotdictionaries,
internal.godotvariants
import internal.godotinternaltypes, internal.godotdictionaries,
internal.godotvariants, internal.godotstrings
type
Dictionary* = ref object

55
godot/core/godotbase.nim
View file

@ -2,61 +2,6 @@
import math
type
Error* {.size: sizeof(cint), pure.} = enum
OK,
Failed, ## Generic fail error
Unavailable, ## What is requested is unsupported/unavailable
Unconfigured, ## The object being used hasnt been properly set up yet
Unauthorized, ## Missing credentials for requested resource
ParameterRangeError, ## Parameter given out of range (5)
OutOfMemory, ## Out of memory
FileNotFound,
FileBadDrive,
FileBadPath,
FileNoPermission, ## (10)
FileAlreadyInUse,
FileCantOpen,
FileCantWrite,
FileCantRead,
FileUnrecognized, ## (15)
FileCorrupt,
FileMissingDependencies,
FileEOF,
CantOpen, ## Can't open a resource/socket/file
CantCreate, ## (20)
QueryFailed,
AlreadyInUse,
Locked, ## resource is locked
Timeout,
CantConnect, ## (25)
CantResolve,
ConnectionError,
CantAquireResource,
CantFork,
InvalidData, ## Data passed is invalid (30)
InvalidParameter, ## Parameter passed is invalid
AlreadyExists, ## When adding, item already exists
DoesNotExist, ## When retrieving/erasing, it item does not exist
DatabaseCantRead, ## Database is full
DatabaseCantWrite, ## Database is full (35)
CompilationFailed,
MethodNotFound,
LinkFailed,
ScriptFailed,
CyclicLink, ## (40)
InvalidDeclaration,
DuplicateSymbol,
PauseError,
Busy,
Skip, ## (45)
Help, ## user requested help!!
Bug,
## a bug in the software certainly happened, due to a double
## check failing or unexpected behavior.
PrinterOnFire, ## the parallel port printer is engulfed in flames
WTF ## shit happens, has never been used, though
# math helpers
const EPSILON = 0.00001'f32

102
godot/core/godotcoretypes.nim Normal file
View file

@ -0,0 +1,102 @@
# Copyright 2017 Xored Software, Inc.
type
Color* {.byref.} = object
r*: float32
g*: float32
b*: float32
a*: float32
Vector3* {.byref.} = object
x*: float32
y*: float32
z*: float32
Vector2* {.byref.} = object
x*: float32
y*: float32
Plane* {.byref.} = object
normal*: Vector3
d*: float32
Basis* {.byref.} = object
elements*: array[3, Vector3]
Quat* {.byref.} = object
x*: float32
y*: float32
z*: float32
w*: float32
Rect3* {.byref.} = object
position*: Vector3
size*: Vector3
Rect2* {.byref.} = object
position*: Vector2
size*: Vector2
Transform2D* {.byref.} = object
elements*: array[3, Vector2]
Transform* {.byref.} = object
basis*: Basis
origin*: Vector3
RID* {.byref.} = object
data: array[sizeof(int), byte]
Error* {.size: sizeof(cint), pure.} = enum
OK,
Failed, ## Generic fail error
Unavailable, ## What is requested is unsupported/unavailable
Unconfigured, ## The object being used hasnt been properly set up yet
Unauthorized, ## Missing credentials for requested resource
ParameterRangeError, ## Parameter given out of range (5)
OutOfMemory, ## Out of memory
FileNotFound,
FileBadDrive,
FileBadPath,
FileNoPermission, ## (10)
FileAlreadyInUse,
FileCantOpen,
FileCantWrite,
FileCantRead,
FileUnrecognized, ## (15)
FileCorrupt,
FileMissingDependencies,
FileEOF,
CantOpen, ## Can't open a resource/socket/file
CantCreate, ## (20)
QueryFailed,
AlreadyInUse,
Locked, ## resource is locked
Timeout,
CantConnect, ## (25)
CantResolve,
ConnectionError,
CantAquireResource,
CantFork,
InvalidData, ## Data passed is invalid (30)
InvalidParameter, ## Parameter passed is invalid
AlreadyExists, ## When adding, item already exists
DoesNotExist, ## When retrieving/erasing, it item does not exist
DatabaseCantRead, ## Database is full
DatabaseCantWrite, ## Database is full (35)
CompilationFailed,
MethodNotFound,
LinkFailed,
ScriptFailed,
CyclicLink, ## (40)
InvalidDeclaration,
DuplicateSymbol,
PauseError,
Busy,
Skip, ## (45)
Help, ## user requested help!!
Bug,
## a bug in the software certainly happened, due to a double
## check failing or unexpected behavior.
PrinterOnFire, ## the parallel port printer is engulfed in flames
WTF ## shit happens, has never been used, though

3
godot/core/nodepaths.nim
View file

@ -1,6 +1,7 @@
# Copyright 2017 Xored Software, Inc.
import internal.godotnodepaths, internal.godotstrings
import internal.godotinternaltypes, internal.godotnodepaths,
internal.godotstrings
type
NodePath* = ref object

105
godot/core/planes.nim
View file

@ -2,72 +2,59 @@
import vector3
import internal.godotstrings
import internal.godotinternaltypes, godotcoretypes, gdnativeapi
type
Plane* {.byref.} = object
normal*: Vector3
d*: float32
proc initPlane*(a, b, c, d: float32): Plane {.inline.} =
getGDNativeAPI().planeNewWithReals(result, a, b, c, d)
proc initPlane(dest: var Plane; a, b, c, d: float32) {.
importc: "godot_plane_new_with_reals".}
proc initPlane(dest: var Plane; v1, v2, v3: Vector3) {.
importc: "godot_plane_new_with_vectors".}
proc initPlane(dest: var Plane; normal: Vector3; d: float32) {.
importc: "godot_plane_new_with_normal".}
proc initPlane*(v1, v2, v3: Vector3): Plane {.inline.} =
getGDNativeAPI().planeNewWithVectors(result, v1, v2, v3)
proc initPlane*(a, b, c, d: float32): Plane =
initPlane(result, a, b, c, d)
proc initPlane*(v1, v2, v3: Vector3): Plane =
initPlane(result, v1, v2, v3)
proc initPlane*(normal: Vector3; d: float32): Plane =
initPlane(result, normal, d)
proc toGodotString(self: Plane): GodotString {.
noSideEffect,
importc: "godot_plane_as_string".}
proc initPlane*(normal: Vector3; d: float32): Plane {.inline.} =
result = Plane(
normal: normal,
d: d
)
proc `$`*(self: Plane): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().planeAsString(self)
proc normalized*(self: Plane): Plane {.inline.} =
getGDNativeAPI().planeNormalized(self)
proc center*(self: Plane): Vector3 {.inline.} =
getGDNativeAPI().planeCenter(self)
proc getAnyPoint*(self: Plane): Vector3 {.inline.} =
getGDNativeAPI().planeGetAnyPoint(self)
proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} =
getGDNativeAPI().planeIsPointOver(self, point)
proc distanceTo*(self: Plane; point: Vector3): float32 {.inline.} =
getGDNativeAPI().planeDistanceTo(self, point)
proc normalized*(self: Plane): Plane {.
noSideEffect,
importc: "godot_plane_normalized".}
proc center*(self: Plane): Vector3 {.
noSideEffect,
importc: "godot_plane_center".}
proc getAnyPoint*(self: Plane): Vector3 {.
noSideEffect,
importc: "godot_plane_get_any_point".}
proc isPointOver*(self: Plane; point: Vector3): bool {.
noSideEffect,
importc: "godot_plane_is_point_over".}
proc distanceTo*(self: Plane; point: Vector3): float32 {.
noSideEffect,
importc: "godot_plane_distance_to".}
proc contains*(self: Plane; point: Vector3;
epsilon: float32): bool {.
noSideEffect,
importc: "godot_plane_has_point".}
proc project*(self: Plane; point: Vector3): Vector3 {.
noSideEffect,
importc: "godot_plane_project".}
epsilon: float32): bool {.inline.} =
getGDNativeAPI().planeHasPoint(self, point, epsilon)
proc project*(self: Plane; point: Vector3): Vector3 {.inline.} =
getGDNativeAPI().planeProject(self, point)
proc intersect3*(self: Plane; dest: var Vector3;
b, c: Plane): bool {.
noSideEffect,
importc: "godot_plane_intersect_3".}
b, c: Plane): bool {.inline.} =
getGDNativeAPI().planeIntersect3(self, dest, b, c)
proc intersectsRay*(self: Plane; dest: var Vector3;
v, dir: Vector3): bool {.
noSideEffect,
importc: "godot_plane_intersects_ray".}
v, dir: Vector3): bool {.inline.} =
getGDNativeAPI().planeIntersectsRay(self, dest, v, dir)
proc intersectsSegment*(self: Plane; dest: var Vector3;
segmentBegin, segmentEnd: Vector3): bool {.
noSideEffect, importc: "godot_plane_intersects_segment".}
proc `-`*(self: Plane): Plane {.
noSideEffect,
importc: "godot_plane_operator_neg".}
proc `==`*(a, b: Plane): bool {.
noSideEffect,
importc: "godot_plane_operator_equal".}
segmentBegin, segmentEnd: Vector3): bool {.inline.} =
getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd)
proc `-`*(self: Plane): Plane {.inline.} =
getGDNativeAPI().planeOperatorNeg(self)
proc `==`*(a, b: Plane): bool {.inline.} =
getGDNativeAPI().planeOperatorEqual(a, b)

15
godot/core/poolarrays.nim
View file

@ -1,7 +1,8 @@
# Copyright 2017 Xored Software, Inc.
import vector2, vector3, colors
import internal.godotpoolarrays, internal.godotstrings
import godotcoretypes
import internal.godotinternaltypes, internal.godotpoolarrays,
internal.godotstrings
template definePoolArrayBase(T, GodotT, DataT, fieldName, newProcName,
initProcName) =
@ -51,9 +52,6 @@ template definePoolArray(T, GodotT, DataT, fieldName, newProcName, initProcName;
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)
@ -93,7 +91,7 @@ definePoolArrayBase(PoolStringArray, GodotPoolStringArray, string,
godotPoolStringArray, newPoolStringArray,
initGodotPoolStringArray)
import godotbase, arrays
import arrays
definePoolArray(PoolByteArray, GodotPoolByteArray, uint8,
godotPoolByteArray, newPoolByteArray,
@ -122,11 +120,6 @@ proc add*(self: var PoolStringArray; data: string) =
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)

127
godot/core/quats.nim
View file

@ -1,91 +1,78 @@
# Copyright (c) 2017 Xored Software, Inc.
import vector3
import internal.godotstrings
type
Quat* {.byref.} = object
x*: float32
y*: float32
z*: float32
w*: float32
proc initQuat(dest: var Quat; x, y, z, w: float32) {.
importc: "godot_quat_new".}
proc initQuat(dest: var Quat; axis: Vector3; angle: float32) {.
importc: "godot_quat_new_with_axis_angle".}
import internal.godotinternaltypes, godotcoretypes, gdnativeapi
proc initQuat*(x, y, z, w: float32): Quat {.inline.} =
initQuat(result, x, y, z, w)
result = Quat(
x: x,
y: y,
z: z,
w: w
)
proc initQuat*(axis: Vector3; angle: float32): Quat {.inline.} =
initQuat(result, axis, angle)
proc toGodotString(self: Quat): GodotString {.
noSideEffect,
importc: "godot_quat_as_string".}
getGDNativeAPI().quatNewWithAxisAngle(result, axis, angle)
proc `$`*(self: Quat): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().quatAsString(self)
proc length*(self: Quat): float32 {.inline.} =
getGDNativeAPI().quatLength(self)
proc lengthSquared*(self: Quat): float32 {.inline.} =
getGDNativeAPI().quatLengthSquared(self)
proc normalized*(self: Quat): Quat {.inline.} =
getGDNativeAPI().quatNormalized(self)
proc isNormalized*(self: Quat): bool {.inline.} =
getGDNativeAPI().quatIsNormalized(self)
proc inverse*(self: Quat): Quat {.inline.} =
getGDNativeAPI().quatInverse(self)
proc dot*(a, b: Quat): float32 {.inline.} =
getGDNativeAPI().quatDot(a, b)
proc xform*(self: Quat; v: Vector3): Vector3 {.inline.} =
getGDNativeAPI().quatXform(self, v)
proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
getGDNativeAPI().quatSlerp(self, b, t)
proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
getGDNativeAPI().quatSlerpni(self, b, t)
proc cubicSlerp*(self, b, preA, postB: Quat;
t: float32): Quat {.inline.} =
getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t)
proc `*`*(a: Quat, b: float32): Quat {.inline.} =
getGDNativeAPI().quatOperatorMultiply(a, b)
proc length*(self: Quat): float32 {.
noSideEffect,
importc: "godot_quat_length".}
proc lengthSquared*(self: Quat): float32 {.
noSideEffect,
importc: "godot_quat_length_squared".}
proc normalized*(self: Quat): Quat {.
noSideEffect,
importc: "godot_quat_normalized".}
proc isNormalized*(self: Quat): bool {.
noSideEffect,
importc: "godot_quat_is_normalized".}
proc inverse*(self: Quat): Quat {.
noSideEffect,
importc: "godot_quat_inverse".}
proc dot*(a, b: Quat): float32 {.
noSideEffect,
importc: "godot_quat_dot".}
proc xform*(self: Quat; v: Vector3): Vector3 {.
noSideEffect,
importc: "godot_quat_xform".}
proc slerp*(self: Quat; b: Quat; t: float32): Quat {.
noSideEffect,
importc: "godot_quat_slerp".}
proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.
noSideEffect,
importc: "godot_quat_slerpni".}
proc cubicSlerp*(self, b, pre_a, post_b: Quat;
t: float32): Quat {.
noSideEffect,
importc: "godot_quat_cubic_slerp".}
proc `*`*(a: Quat, b: float32): Quat {.
noSideEffect,
importc: "godot_quat_operator_multiply".}
proc `*=`*(a: var Quat, b: float32) {.inline.} =
a = a * b
proc `+`*(a, b: Quat): Quat {.
noSideEffect,
importc: "godot_quat_operator_add".}
proc `+`*(a, b: Quat): Quat {.inline.} =
getGDNativeAPI().quatOperatorAdd(a, b)
proc `+=`*(a: var Quat, b: Quat) {.inline.} =
a = a + b
proc `-`*(a, b: Quat): Quat {.
noSideEffect,
importc: "godot_quat_operator_substract".}
proc `-`*(a, b: Quat): Quat {.inline.} =
getGDNativeAPI().quatOperatorSubtract(a, b)
proc `-=`* (a: var Quat, b: Quat) {.inline.} =
a = a - b
proc `/`*(self: Quat; b: float32): Quat {.
noSideEffect,
importc: "godot_quat_operator_divide".}
proc `/`*(self: Quat; b: float32): Quat {.inline.} =
getGDNativeAPI().quatOperatorDivide(self, b)
proc `/=`*(self: var Quat, b: float32) {.inline.} =
self = self / b
proc `==`*(a, b: Quat): bool {.
noSideEffect,
importc: "godot_quat_operator_equal".}
proc `-`*(self: Quat): Quat {.
noSideEffect,
importc: "godot_quat_operator_neg".}
proc `==`*(a, b: Quat): bool {.inline.} =
getGDNativeAPI().quatOperatorEqual(a, b)
proc `-`*(self: Quat): Quat {.inline.} =
getGDNativeAPI().quatOperatorNeg(self)

73
godot/core/rect2.nim
View file

@ -1,13 +1,7 @@
# Copyright (c) 2017 Xored Software, Inc.
import vector2
import internal.godotstrings
type
Rect2* {.byref.} = object
position*: Vector2
size*: Vector2
import godotcoretypes, internal.godotinternaltypes, gdnativeapi
proc initRect2*(pos, size: Vector2): Rect2 {.inline.} =
Rect2(position: pos, size: size)
@ -15,40 +9,35 @@ proc initRect2*(pos, size: Vector2): Rect2 {.inline.} =
proc initRect2*(x, y, sizeX, sizeY: float32): Rect2 {.inline.} =
Rect2(position: vec2(x, y), size: vec2(sizeX, sizeY))
proc toGodotString(self: Rect2): GodotString {.
noSideEffect,
importc: "godot_rect2_as_string".}
proc `$`*(self: Rect2): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().rect2AsString(self)
proc area*(self: Rect2): float32 {.
noSideEffect,
importc: "godot_rect2_get_area".}
proc intersects*(a, b: Rect2): bool {.
noSideEffect,
importc: "godot_rect2_intersects".}
proc encloses*(a, b: Rect2): bool {.
noSideEffect,
importc: "godot_rect2_encloses".}
proc hasNoArea*(self: Rect2): bool {.
noSideEffect,
importc: "godot_rect2_has_no_area".}
proc clip*(a, b: Rect2): Rect2 {.
noSideEffect,
importc: "godot_rect2_clip".}
proc merge*(a, b: Rect2): Rect2 {.
noSideEffect,
importc: "godot_rect2_merge".}
proc contains*(self: Rect2; point: Vector2): bool {.
noSideEffect,
importc: "godot_rect2_has_point".}
proc grow*(self: Rect2; by: float32): Rect2 {.
noSideEffect,
importc: "godot_rect2_grow".}
proc expand*(self: Rect2; to: Vector2): Rect2 {.
noSideEffect,
importc: "godot_rect2_expand".}
proc `==`*(a, b: Rect2): bool {.
noSideEffect,
importc: "godot_rect2_operator_equal".}
proc area*(self: Rect2): float32 {.inline.} =
getGDNativeAPI().rect2GetArea(self)
proc intersects*(a, b: Rect2): bool {.inline.} =
getGDNativeAPI().rect2Intersects(a, b)
proc encloses*(a, b: Rect2): bool {.inline.} =
getGDNativeAPI().rect2Encloses(a, b)
proc hasNoArea*(self: Rect2): bool {.inline.} =
getGDNativeAPI().rect2HasNoArea(self)
proc clip*(self, b: Rect2): Rect2 {.inline.} =
getGDNativeAPI().rect2Clip(self, b)
proc merge*(self, b: Rect2): Rect2 {.inline.} =
getGDNativeAPI().rect2Merge(self, b)
proc contains*(self: Rect2; point: Vector2): bool {.inline.} =
getGDNativeAPI().rect2HasPoint(self, point)
proc grow*(self: Rect2; by: float32): Rect2 {.inline.} =
getGDNativeAPI().rect2Grow(self, by)
proc expand*(self: Rect2; to: Vector2): Rect2 {.inline.} =
getGDNativeAPI().rect2Expand(self, to)
proc `==`*(a, b: Rect2): bool {.inline.} =
getGDNativeAPI().rect2OperatorEqual(a, b)

140
godot/core/rect3.nim
View file

@ -1,84 +1,72 @@
# Copyright (c) 2017 Xored Software, Inc.
import planes, vector3
import internal.godotstrings
type
Rect3* {.byref.} = object
position*: Vector3
size*: Vector3
import godotcoretypes, internal.godotinternaltypes, gdnativeapi
proc initRect3*(pos, size: Vector3): Rect3 {.inline.} =
Rect3(position: pos, size: size)
proc toGodotString(self: Rect3): GodotString {.
noSideEffect,
importc: "godot_rect3_as_string".}
proc `$`*(self: Rect3): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().rect3AsString(self)
proc area*(self: Rect3): float32 {.
noSideEffect,
importc: "godot_rect3_get_area".}
proc hasNoArea*(self: Rect3): bool {.
noSideEffect,
importc: "godot_rect3_has_no_area".}
proc hasNoSurface*(self: Rect3): bool {.
noSideEffect,
importc: "godot_rect3_has_no_surface".}
proc intersects*(a, b: Rect3): bool {.
noSideEffect,
importc: "godot_rect3_intersects".}
proc encloses*(self, other: Rect3): bool {.
noSideEffect,
importc: "godot_rect3_encloses".}
proc merge*(self, other: Rect3): Rect3 {.
noSideEffect,
importc: "godot_rect3_merge".}
proc intersection*(self, other: Rect3): Rect3 {.
noSideEffect,
importc: "godot_rect3_intersection".}
proc intersectsPlane*(self: Rect3; plane: Plane): bool {.
noSideEffect,
importc: "godot_rect3_intersects_plane".}
proc intersectsSegment*(self: Rect3; start, to: Vector3): bool {.
noSideEffect,
importc: "godot_rect3_intersects_segment".}
proc contains*(self: Rect3; point: Vector3): bool {.
noSideEffect,
importc: "godot_rect3_has_point".}
proc getSupport*(self: Rect3; dir: Vector3): Vector3 {.
noSideEffect,
importc: "godot_rect3_get_support".}
proc getLongestAxis*(self: Rect3): Vector3 {.
noSideEffect,
importc: "godot_rect3_get_longest_axis".}
proc getLongestAxisIndex*(self: Rect3): cint {.
noSideEffect,
importc: "godot_rect3_get_longest_axis_index".}
proc getLongestAxisSize*(self: Rect3): float32 {.
noSideEffect,
importc: "godot_rect3_get_longest_axis_size".}
proc getShortestAxis*(self: Rect3): Vector3 {.
noSideEffect,
importc: "godot_rect3_get_shortest_axis".}
proc getShortestAxisIndex*(self: Rect3): cint {.
noSideEffect,
importc: "godot_rect3_get_shortest_axis_index".}
proc getShortestAxisSize*(self: Rect3): float32 {.
noSideEffect,
importc: "godot_rect3_get_shortest_axis_size".}
proc expand*(self: Rect3; toPoint: Vector3): Rect3 {.
noSideEffect,
importc: "godot_rect3_expand".}
proc grow*(self: Rect3; by: float32): Rect3 {.
noSideEffect,
importc: "godot_rect3_grow".}
proc getEndpoint*(self: Rect3; idx: cint): Vector3 {.
noSideEffect,
importc: "godot_rect3_get_endpoint".}
proc `==`*(a, b: Rect3): bool {.
noSideEffect,
importc: "godot_rect3_operator_equal".}
proc area*(self: Rect3): float32 {.inline.} =
getGDNativeAPI().rect3GetArea(self)
proc hasNoArea*(self: Rect3): bool {.inline.} =
getGDNativeAPI().rect3HasNoArea(self)
proc hasNoSurface*(self: Rect3): bool {.inline.} =
getGDNativeAPI().rect3HasNoSurface(self)
proc intersects*(self, other: Rect3): bool {.inline.} =
getGDNativeAPI().rect3Intersects(self, other)
proc encloses*(self, other: Rect3): bool {.inline.} =
getGDNativeAPI().rect3Encloses(self, other)
proc merge*(self, other: Rect3): Rect3 {.inline.} =
getGDNativeAPI().rect3Merge(self, other)
proc intersection*(self, other: Rect3): Rect3 {.inline.} =
getGDNativeAPI().rect3Intersection(self, other)
proc intersectsPlane*(self: Rect3; plane: Plane): bool {.inline.} =
getGDNativeAPI().rect3IntersectsPlane(self, plane)
proc intersectsSegment*(self: Rect3; start, to: Vector3): bool {.inline.} =
getGDNativeAPI().rect3IntersectsSegment(self, start, to)
proc contains*(self: Rect3; point: Vector3): bool {.inline.} =
getGDNativeAPI().rect3HasPoint(self, point)
proc getSupport*(self: Rect3; dir: Vector3): Vector3 {.inline.} =
getGDNativeAPI().rect3GetSupport(self, dir)
proc getLongestAxis*(self: Rect3): Vector3 {.inline.} =
getGDNativeAPI().rect3GetLongestAxis(self)
proc getLongestAxisIndex*(self: Rect3): cint {.inline.} =
getGDNativeAPI().rect3GetLongestAxisIndex(self)
proc getLongestAxisSize*(self: Rect3): float32 {.inline.} =
getGDNativeAPI().rect3GetLongestAxisSize(self)
proc getShortestAxis*(self: Rect3): Vector3 {.inline.} =
getGDNativeAPI().rect3GetShortestAxis(self)
proc getShortestAxisIndex*(self: Rect3): cint {.inline.} =
getGDNativeAPI().rect3GetShortestAxisIndex(self)
proc getShortestAxisSize*(self: Rect3): float32 {.inline.} =
getGDNativeAPI().rect3GetShortestAxisSize(self)
proc expand*(self: Rect3; toPoint: Vector3): Rect3 {.inline.} =
getGDNativeAPI().rect3Expand(self, toPoint)
proc grow*(self: Rect3; by: float32): Rect3 {.inline.} =
getGDNativeAPI().rect3Grow(self, by)
proc getEndpoint*(self: Rect3; idx: cint): Vector3 {.inline.} =
getGDNativeAPI().rect3GetEndpoint(self, idx)
proc `==`*(a, b: Rect3): bool {.inline.} =
getGDNativeAPI().rect3OperatorEqual(a, b)

32
godot/core/rids.nim
View file

@ -1,31 +1,21 @@
import internal.godotobjects
# Copyright (c) 2017 Xored Software, Inc.
type
RID* {.byref.} = object
data: array[sizeof(int), byte]
proc initRID(dest: var RID) {.
importc: "godot_rid_new".}
proc initRID(dest: var RID; obj: ptr GodotObject) {.
importc: "godot_rid_new_with_resource".}
import godotcoretypes, internal.godotinternaltypes, gdnativeapi
proc initRID*(): RID {.inline.} =
initRID(result)
getGDNativeAPI().ridNew(result)
proc initRID*(obj: ptr GodotObject): RID {.inline.} =
initRID(result, obj)
proc idCInt(self: RID): cint {.
noSideEffect,
importc: "godot_rid_get_id".}
getGDNativeAPI().ridNewWithResource(result, obj)
proc id*(self: RID): uint32 {.inline.} =
cast[uint32](self.idCInt())
cast[uint32](getGDNativeAPI().ridGetId(self))
proc `$`*(self: RID): string =
proc `$`*(self: RID): string {.inline.} =
$self.id
proc `==`*(a, b: RID): bool {.
importc: "godot_rid_operator_equal".}
proc `<`*(a, b: RID): bool {.
importc: "godot_rid_operator_less".}
proc `==`*(a, b: RID): bool {.inline.} =
getGDNativeAPI().ridOperatorEqual(a, b)
proc `<`*(a, b: RID): bool {.inline.} =
getGDNativeAPI().ridOperatorLess(a, b)

117
godot/core/transform2d.nim
View file

@ -1,76 +1,73 @@
# Copyright (c) 2017 Xored Software, Inc.
import vector2, rect2
import internal.godotstrings
type
Transform2D* {.byref.} = object
elements*: array[3, Vector2]
proc initTransform2D(dest: var Transform2D) {.
importc: "godot_transform2d_new_identity".}
proc initTransform2D(dest: var Transform2D; rot: float32; pos: Vector2) {.
importc: "godot_transform2d_new".}
proc initTransform2D(dest: var Transform2D; xAxis, yAxis, origin: Vector2) {.
importc: "godot_transform2d_new_axis_origin".}
import godotcoretypes, internal.godotinternaltypes, gdnativeapi
proc initTransform2D*(): Transform2D {.inline.} =
initTransform2D(result)
getGDNativeAPI().transform2DNewIdentity(result)
proc initTransform2D*(rot: float32; pos: Vector2): Transform2D {.inline.} =
initTransform2D(result, rot, pos)
getGDNativeAPI().transform2DNew(result, rot, pos)
proc initTransform2D*(xAxis, yAxis, origin: Vector2): Transform2D {.inline.} =
initTransform2D(result, xAxis, yAxis, origin)
proc toGodotString(self: Transform2D): GodotString {.
importc: "godot_transform2d_as_string".}
getGDNativeAPI().transform2DNewAxisOrigin(result, xAxis, yAxis, origin)
proc `$`*(self: Transform2D): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().transform2DAsString(self)
proc inverse*(self: Transform2D): Transform2D {.
importc: "godot_transform2d_inverse".}
proc affineInverse*(self: Transform2D): Transform2D {.
importc: "godot_transform2d_affine_inverse".}
proc rotation*(self: Transform2D): float32 {.
importc: "godot_transform2d_get_rotation".}
proc origin*(self: Transform2D): Vector2 {.
importc: "godot_transform2d_get_origin".}
proc scale*(self: Transform2D): Vector2 {.
importc: "godot_transform2d_get_scale".}
proc orthonormalized*(self: Transform2D): Transform2D {.
importc: "godot_transform2d_orthonormalized".}
proc rotated*(self: Transform2D; phi: float32): Transform2D {.
importc: "godot_transform2d_rotated".}
proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.
importc: "godot_transform2d_scaled".}
proc translated*(self: Transform2D;
offset: Vector2): Transform2D {.
importc: "godot_transform2d_translated".}
proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.
importc: "godot_transform2d_xform_vector2".}
proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.
importc: "godot_transform2d_xform_inv_vector2".}
proc basisXformVector2*(self: Transform2D;
v: Vector2): Vector2 {.
importc: "godot_transform2d_basis_xform_vector2".}
proc basisXformInvVector2*(self: Transform2D;
v: Vector2): Vector2 {.
importc: "godot_transform2d_basis_xform_inv_vector2".}
proc xformRect2*(self: Transform2D; v: Rect2): Rect2 {.
importc: "godot_transform2d_xform_rect2".}
proc xformInvRect2*(self: Transform2D; v: Rect2): Rect2 {.
importc: "godot_transform2d_xform_inv_rect2".}
proc inverse*(self: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DInverse(self)
proc affineInverse*(self: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DAffineInverse(self)
proc rotation*(self: Transform2D): float32 {.inline.} =
getGDNativeAPI().transform2DGetRotation(self)
proc origin*(self: Transform2D): Vector2 {.inline.} =
getGDNativeAPI().transform2DGetOrigin(self)
proc scale*(self: Transform2D): Vector2 {.inline.} =
getGDNativeAPI().transform2DGetScale(self)
proc orthonormalized*(self: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DOrthonormalized(self)
proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} =
getGDNativeAPI().transform2DRotated(self, phi)
proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} =
getGDNativeAPI().transform2DScaled(self, scale)
proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} =
getGDNativeAPI().transform2DTranslated(self, offset)
proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DXformVector2(self, v)
proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DXformInvVector2(self, v)
proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DBasisXformVector2(self, v)
proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DBasisXformInvVector2(self, v)
proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
getGDNativeAPI().transform2DXformRect2(self, rect)
proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
getGDNativeAPI().transform2DXformInvRect2(self, rect)
proc interpolateWith*(self, m: Transform2D;
c: float32): Transform2D {.
importc: "godot_transform2d_interpolate_with".}
proc `==`*(a, b: Transform2D): bool {.
importc: "godot_transform2d_operator_equal".}
proc `*`*(a, b: Transform2D): Transform2D {.
importc: "godot_transform2d_operator_multiply".}
c: float32): Transform2D {.inline.} =
getGDNativeAPI().transform2DInterpolateWith(self, m, c)
proc `==`*(a, b: Transform2D): bool {.inline.} =
getGDNativeAPI().transform2DOperatorEqual(a, b)
proc `*`*(a, b: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DOperatorMultiply(a, b)
proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} =
a = a * b

93
godot/core/transforms.nim
View file

@ -1,13 +1,7 @@
# Copyright (c) 2017 Xored Software, Inc.
import basis, vector3, planes, rect3
import internal.godotstrings
type
Transform* {.byref.} = object
basis*: Basis
origin*: Vector3
import godotcoretypes, internal.godotinternaltypes, gdnativeapi
import basis
proc initTransform*(): Transform {.inline.} =
result.basis = initBasis()
@ -23,45 +17,54 @@ proc initTransform*(xAxis, yAxis, zAxis,
proc initTransform*(basis: Basis, origin: Vector3): Transform {.inline.} =
Transform(basis: basis, origin: origin)
proc toGodotString(self: Transform): GodotString {.
importc: "godot_transform_as_string".}
proc `$`*(self: Transform): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().transformAsString(self)
proc inverse*(self: Transform): Transform {.inline.} =
getGDNativeAPI().transformInverse(self)
proc affineInverse*(self: Transform): Transform {.inline.} =
getGDNativeAPI().transformAffineInverse(self)
proc orthonormalized*(self: Transform): Transform {.inline.} =
getGDNativeAPI().transformOrthonormalized(self)
proc inverse*(self: Transform): Transform {.
importc: "godot_transform_inverse".}
proc affineInverse*(self: Transform): Transform {.
importc: "godot_transform_affine_inverse".}
proc orthonormalized*(self: Transform): Transform {.
importc: "godot_transform_orthonormalized".}
proc rotated*(self: Transform; axis: Vector3;
phi: float32): Transform {.
importc: "godot_transform_rotated".}
proc scaled*(self: Transform; scale: Vector3): Transform {.
importc: "godot_transform_scaled".}
proc translated*(self: Transform; offset: Vector3): Transform {.
importc: "godot_transform_translated".}
proc lookingAt*(self: Transform;
target, up: Vector3): Transform {.
importc: "godot_transform_looking_at".}
phi: float32): Transform {.inline.} =
getGDNativeAPI().transformRotated(self, axis, phi)
proc xformPlane*(self: Transform; v: Plane): Plane {.
importc: "godot_transform_xform_plane".}
proc xformInvPlane*(self: Transform; v: Plane): Plane {.
importc: "godot_transform_xform_inv_plane".}
proc xformVector3*(self: Transform; v: Vector3): Vector3 {.
importc: "godot_transform_xform_vector3".}
proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.
importc: "godot_transform_xform_inv_vector3".}
proc xformRect3*(self: Transform; v: Rect3): Rect3 {.
importc: "godot_transform_xform_rect3".}
proc xformInvRect3*(self: Transform; v: Rect3): Rect3 {.
importc: "godot_transform_xform_inv_rect3".}
proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} =
getGDNativeAPI().transformScaled(self, scale)
proc `==`*(self: Transform; b: Transform): bool {.
importc: "godot_transform_operator_equal".}
proc `*`*(a, b: Transform): Transform {.
importc: "godot_transform_operator_multiply".}
proc `*=`*(a: var Transform, b: Transform) {.inline.} =
a = a * b
proc translated*(self: Transform; offset: Vector3): Transform {.inline.} =
getGDNativeAPI().transformTranslated(self, offset)
proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} =
getGDNativeAPI().transformLookingAt(self, target, up)
proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} =
getGDNativeAPI().transformXformPlane(self, plane)
proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} =
getGDNativeAPI().transformXformInvPlane(self, plane)
proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
getGDNativeAPI().transformXformVector3(self, v)
proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
getGDNativeAPI().transformXformInvVector3(self, v)
proc xformRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} =
getGDNativeAPI().transformXformRect3(self, rect)
proc xformInvRect3*(self: Transform; rect: Rect3): Rect3 {.inline.} =
getGDNativeAPI().transformXformInvRect3(self, rect)
proc `==`*(self: Transform; b: Transform): bool {.inline.} =
getGDNativeAPI().transformOperatorEqual(self, b)
proc `*`*(self, other: Transform): Transform {.inline.} =
getGDNativeAPI().transformOperatorMultiply(self, other)
proc `*=`*(self: var Transform, other: Transform) {.inline.} =
self = self * other

9
godot/core/variants.nim
View file

@ -1,7 +1,8 @@
import tables
import internal.godotobjects, internal.godotvariants, internal.godotpoolarrays,
internal.godotstrings, internal.godotnodepaths
import godotcoretypes
import internal.godotinternaltypes, internal.godotvariants,
internal.godotstrings
type
Variant* = ref object
@ -267,5 +268,5 @@ proc `<`*(self, other: Variant): bool =
proc hashCompare*(self, other: Variant): bool =
self.godotVariant.hashCompare(other.godotVariant)
proc booleanize*(self: Variant; isValid: var bool): bool =
self.godotVariant.booleanize(isValid)
proc booleanize*(self: Variant): bool =
self.godotVariant.booleanize()

188
godot/core/vector2.nim
View file

@ -1,109 +1,121 @@
# Copyright (c) 2017 Xored Software, Inc.
import internal.godotstrings
type
Vector2* {.byref.} = object
x*: float32
y*: float32
import internal.godotinternaltypes, godotcoretypes, gdnativeapi
proc vec2*(x, y: float32): Vector2 {.inline.} =
Vector2(x: x, y: y)
proc toGodotString(self: Vector2): GodotString {.
importc: "godot_vector2_as_string".}
proc `$`*(self: Vector2): string {.inline.} =
$self.toGodotString()
$getGDNativeAPI().vector2AsString(self)
proc normalized*(self: Vector2): Vector2 {.
importc: "godot_vector2_normalized".}
proc length*(self: Vector2): float32 {.
importc: "godot_vector2_length".}
proc angle*(self: Vector2): float32 {.
importc: "godot_vector2_angle".}
proc lengthSquared*(self: Vector2): float32 {.
importc: "godot_vector2_length_squared".}
proc isNormalized*(self: Vector2): bool {.
importc: "godot_vector2_is_normalized".}
proc distanceTo*(self, to: Vector2): float32 {.
importc: "godot_vector2_distance_to".}
proc distanceSquaredTo*(self, to: Vector2): float32 {.
importc: "godot_vector2_distance_squared_to".}
proc angleTo*(self, to: Vector2): float32 {.
importc: "godot_vector2_angle_to".}
proc angleToPoint*(self, to: Vector2): float32 {.
importc: "godot_vector2_angle_to_point".}
proc lerp*(self, b: Vector2; t: float32): Vector2 {.
importc: "godot_vector2_linear_interpolate".}
proc cubicInterpolate*(self, b, pre_a, post_b: Vector2; t: float32): Vector2 {.
importc: "godot_vector2_cubic_interpolate".}
proc rotated*(self: Vector2; phi: float32): Vector2 {.
importc: "godot_vector2_rotated".}
proc tangent*(self: Vector2): Vector2 {.
importc: "godot_vector2_tangent".}
proc floor*(self: Vector2): Vector2 {.
importc: "godot_vector2_floor".}
proc snapped*(self: Vector2; by: Vector2): Vector2 {.
importc: "godot_vector2_snapped".}
proc aspect*(self: Vector2): float32 {.
importc: "godot_vector2_aspect".}
proc dot*(a, b: Vector2): float32 {.
importc: "godot_vector2_dot".}
proc slide*(self, n: Vector2): Vector2 {.
importc: "godot_vector2_slide".}
proc bounce*(self, n: Vector2): Vector2 {.
importc: "godot_vector2_bounce".}
proc reflect*(self, n: Vector2): Vector2 {.
importc: "godot_vector2_reflect".}
proc abs*(self: Vector2): Vector2 {.
importc: "godot_vector2_abs".}
proc clamped*(self: Vector2; length: float32): Vector2 {.
importc: "godot_vector2_clamped".}
proc normalized*(self: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Normalized(self)
proc `+`*(a, b: Vector2): Vector2 {.
importc: "godot_vector2_operator_add".}
proc `+=`*(a: var Vector2, b: Vector2) {.inline.} =
a += b
proc length*(self: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2Length(self)
proc `-`*(a, b: Vector2): Vector2 {.
importc: "godot_vector2_operator_substract".}
proc `-=`*(a: var Vector2, b: Vector2) {.inline.} =
a = a - b
proc angle*(self: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2Angle(self)
proc `*`*(a, b: Vector2): Vector2 {.
importc: "godot_vector2_operator_multiply_vector".}
proc lengthSquared*(self: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2LengthSquared(self)
proc `*=`*(a: var Vector2, b: Vector2) {.inline.} =
a = a * b
proc isNormalized*(self: Vector2): bool {.inline.} =
getGDNativeAPI().vector2IsNormalized(self)
proc distanceTo*(self, to: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2DistanceTo(self, to)
proc distanceSquaredTo*(self, to: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2DistanceSquaredTo(self, to)
proc angleTo*(self, to: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2AngleTo(self, to)
proc angleToPoint*(self, to: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2AngleToPoint(self, to)
proc lerp*(self, b: Vector2; t: float32): Vector2 {.inline.} =
getGDNativeAPI().vector2LinearInterpolate(self, b, t)
proc cubicInterpolate*(self, b, preA, postB: Vector2;
t: float32): Vector2 {.inline.} =
getGDNativeAPI().vector2CubicInterpolate(self, b, preA, postB, t)
proc rotated*(self: Vector2; phi: float32): Vector2 {.inline.} =
getGDNativeAPI().vector2Rotated(self, phi)
proc tangent*(self: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Tangent(self)
proc floor*(self: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Floor(self)
proc snapped*(self: Vector2; by: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Snapped(self, by)
proc aspect*(self: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2Aspect(self)
proc dot*(a, b: Vector2): float32 {.inline.} =
getGDNativeAPI().vector2Dot(a, b)
proc slide*(self, n: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Slide(self, n)
proc bounce*(self, n: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Bounce(self, n)
proc reflect*(self, n: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Reflect(self, n)
proc abs*(self: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2Abs(self)
proc clamped*(self: Vector2; length: float32): Vector2 {.inline.} =
getGDNativeAPI().vector2Clamped(self, length)
proc `+`*(self, other: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2OperatorAdd(self, other)
proc `+=`*(self: var Vector2, other: Vector2) {.inline.} =
self += other
proc `-`*(self, other: Vector2): Vector2 =
getGDNativeAPI().vector2OperatorSubtract(self, other)
proc `-=`*(self: var Vector2, other: Vector2) {.inline.} =
self = self - other
proc `*`*(self, other: Vector2): Vector2 =
getGDNativeAPI().vector2OperatorMultiplyVector(self, other)
proc `*=`*(self: var Vector2, other: Vector2) {.inline.} =
self = self * other
proc `*`*(self: Vector2, scalar: float32): Vector2 =
getGDNativeAPI().vector2OperatorMultiplyScalar(self, scalar)
proc `*`*(self: Vector2, scalar: float32): Vector2 {.
importc: "godot_vector2_operator_multiply_scalar".}
proc `*=`*(self: var Vector2, scalar: float32) {.inline.} =
self = self * scalar
proc `/`*(a, b: Vector2): Vector2 {.
importc: "godot_vector2_operator_divide_vector".}
proc `/=`*(a: var Vector2, b: Vector2) {.inline.} =
a = a / b
proc `/`*(self, other: Vector2): Vector2 =
getGDNativeAPI().vector2OperatorDivideVector(self, other)
proc `/=`*(self: var Vector2, other: Vector2) {.inline.} =
self = self / other
proc `/`*(self: Vector2; scalar: float32): Vector2 =
getGDNativeAPI().vector2OperatorDivideScalar(self, scalar)
proc `/`*(self: Vector2; scalar: float32): Vector2 {.
importc: "godot_vector2_operator_divide_scalar".}
proc `/=`*(self: var Vector2; scalar: float32) {.inline.} =
self = self / scalar
proc `==`*(a, b: Vector2): bool {.
importc: "godot_vector2_operator_equal".}
proc `<`*(a, b: Vector2): bool {.
importc: "godot_vector2_operator_less".}
proc `-`*(self: Vector2): Vector2 {.
importc: "godot_vector2_operator_neg".}
proc `==`*(self, other: Vector2): bool {.inline.} =
getGDNativeAPI().vector2OperatorEqual(self, other)
proc `x=`*(self: var Vector2; x: float32) {.
importc: "godot_vector2_set_x".}
proc `y=`*(self: var Vector2; y: float32) {.
importc: "godot_vector2_set_y".}
proc x*(self: Vector2): float32 {.
importc: "godot_vector2_get_x".}
proc y*(self: Vector2): float32 {.
importc: "godot_vector2_get_y".}
proc `<`*(self, other: Vector2): bool {.inline.} =
getGDNativeAPI().vector2OperatorLess(self, other)
proc `-`*(self: Vector2): Vector2 {.inline.} =
getGDNativeAPI().vector2OperatorNeg(self)

8
godot/core/vector3.nim
View file

@ -1,13 +1,7 @@
# Copyright (c) 2017 Xored Software, Inc.
import math
import godotbase
type
Vector3* {.byref.} = object
x*: float32
y*: float32
z*: float32
import godotbase, godotcoretypes
proc vec3*(): Vector3 {.inline.} =
Vector3()

1378
godot/gdnativeapi.nim Normal file
View file

File diff suppressed because it is too large Load diff

7
godot/godot.nim
View file

@ -1,6 +1,7 @@
# Copyright 2017 Xored Software, Inc.
import core.godotbase, godotinternal
import core.godotcoretypes
import core.vector2, core.rect2, core.vector3, core.transform2d, core.planes,
core.quats
import core.rect3, core.basis, core.transforms, core.colors, core.nodepaths,
@ -9,9 +10,9 @@ import core.dictionaries, core.arrays, core.poolarrays, core.variants
import nim.godotmacros, nim.godotnim
export godotbase, vector2, rect2, vector3, transform2d, planes, quats,
rect3, basis, transforms, colors, nodepaths, rids, dictionaries, arrays,
poolarrays, variants
export godotbase, godotcoretypes, vector2, rect2, vector3, transform2d, planes,
quats, rect3, basis, transforms, colors, nodepaths, rids, dictionaries,
arrays, poolarrays, variants
export godotmacros, godotnim
export GodotPropertyHint, GodotPropertyUsage

307
godot/godotinternal.nim
View file

@ -1,259 +1,87 @@
# Copyright 2017 Xored Software, Inc.
import internal.godotobjects, internal.godotarrays, internal.godotnodepaths,
internal.godotpoolarrays, internal.godotstrings, internal.godotvariants,
internal.godotdictionaries
import internal.godotinternaltypes, internal.godotarrays,
internal.godotnodepaths, internal.godotpoolarrays, internal.godotstrings,
internal.godotvariants, internal.godotdictionaries
export godotobjects, godotarrays, godotnodepaths, godotpoolarrays,
import gdnativeapi
export godotinternaltypes, godotarrays, godotnodepaths, godotpoolarrays,
godotstrings, godotvariants, godotdictionaries
const MAX_ARG_COUNT* = 128
proc getMethod*(className: cstring;
methodName: cstring): ptr GodotMethodBind {.inline.} =
getGDNativeAPI().methodBindGetMethod(className, methodName)
# MethodBind API
type GodotMethodBind* = object
proc getMethod*(className: cstring; methodName: cstring): ptr GodotMethodBind {.
importc: "godot_method_bind_get_method".}
proc ptrCall*(methodBind: ptr GodotMethodBind;
instance: ptr GodotObject;
args: ptr array[MAX_ARG_COUNT, pointer];
ret: pointer) {.
importc: "godot_method_bind_ptrcall".}
ret: pointer) {.inline.} =
getGDNativeAPI().methodBindPtrCall(methodBind, instance, args, ret)
proc call*(methodBind: ptr GodotMethodBind;
instance: ptr GodotObject;
args: ptr array[MAX_ARG_COUNT, ptr GodotVariant]; argCount: cint;
callError: var VariantCallError): GodotVariant {.
importc: "godot_method_bind_call".}
callError: var VariantCallError): GodotVariant {.inline.} =
getGDNativeAPI().methodBindCall(
methodBind, instance, args, argCount, callError)
# Script API
proc nativeScriptRegisterClass*(libHandle: pointer; name, base: cstring;
createFunc: GodotInstanceCreateFunc;
destroyFunc: GodotInstanceDestroyFunc)
{.inline.} =
let api = getGDNativeAPI()
api.nativeScriptRegisterClass(
libHandle, name, base, createFunc, destroyFunc)
type
GodotNativeInitOptions* = object
inEditor*: bool
coreApiHash*: uint64
editorApiHash*: uint64
noApiHash*: uint64
gdNativeLibrary*: ptr GodotObject
proc nativeScriptRegisterToolClass*(libHandle: pointer; name, base: cstring;
createFunc: GodotInstanceCreateFunc;
destroyFunc: GodotInstanceDestroyFunc)
{.inline.} =
getGDNativeAPI().nativeScriptRegisterToolClass(
libHandle, name, base, createFunc, destroyFunc)
GodotNativeTerminateOptions* = object
inEditor*: bool
proc nativeScriptRegisterMethod*(libHandle: pointer;
name: cstring; function_name: cstring;
attr: GodotMethodAttributes;
meth: GodotInstanceMethod) {.inline.} =
getGDNativeAPI().nativeScriptRegisterMethod(
libHandle, name, functionName, attr, meth)
GodotMethodRPCMode* {.size: sizeof(cint), pure.} = enum
Disabled,
Remote,
Sync,
Master,
Slave
proc nativeScriptRegisterProperty*(libHandle: pointer;
name, path: cstring;
attr: ptr GodotPropertyAttributes;
setFunc: GodotPropertySetFunc;
getFunc: GodotPropertyGetFunc) {.inline.} =
getGDNativeAPI().nativeScriptRegisterProperty(
libHandle, name, path, attr, setFunc, getFunc)
GodotMethodAttributes* = object
rpcMode*: GodotMethodRPCMode
proc nativeScriptRegisterSignal*(libHandle: pointer; name: cstring;
signal: GodotSignal) {.inline.} =
getGDNativeAPI().nativeScriptRegisterSignal(libHandle, name, signal)
GodotPropertyHint* {.size: sizeof(cint), pure.} = enum
None, ## no hint provided.
Range, ## hint_text = "min,max,step,slider; // slider is optional"
ExpRange, ## hint_text = "min,max,step", exponential edit
Enum, ## hint_text= "val1,val2,val3,etc"
ExpEasing, ## exponential easing funciton (Math::ease)
Length, ## hint_text= "length" (as integer)
SpriteFrame,
KeyAccel, ## hint_text= "length" (as integer)
Flags, ## hint_text= "flag1,flag2,etc" (as bit flags)
Layers2DRender,
Layers2DPhysics,
Layers3DRender,
Layers3DPhysics,
File, ## a file path must be passed, hint_text (optionally)
## is a filter "*.png,*.wav,*.doc,"
Dir, ## a directort path must be passed
GlobalFile, ## a file path must be passed, hint_text (optionally) is a
## filter "*.png,*.wav,*.doc,"
GlobalDir, ## a directort path must be passed
ResourceType, ## a resource object type
MultilineText, ## used for string properties that can contain multiple lines
ColorNoAlpha, ## used for ignoring alpha component when editing a color
ImageCompressLossy,
ImageCompressLossless,
ObjectId,
TypeString, ## a type string, the hint is the base type to choose
NodePathToEditedNode, ## so something else can provide this
## (used in scripts)
MethodOfVariantType, ## a method of a type
MethodOfBaseType, ## a method of a base type
MethodOfInstance, ## a method of an instance
MethodOfScript, ## a method of a script & base
PropertyOfVariantType, ## a property of a type
PropertyOfBaseType, ## a property of a base type
PropertyOfInstance, ## a property of an instance
PropertyOfScript, ## a property of a script & base
PropertyHintMax
proc getUserdata*(instance: ptr GodotObject): pointer {.inline.} =
getGDNativeAPI().nativeScriptGetUserdata(instance)
const
GODOT_PROPERTY_USAGE_STORAGE_VALUE = 1.cint
GODOT_PROPERTY_USAGE_EDITOR_VALUE = 2.cint
GODOT_PROPERTY_USAGE_NETWORK_VALUE = 4.cint
GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE = 8.cint
GODOT_PROPERTY_USAGE_CHECKABLE_VALUE = 16.cint
GODOT_PROPERTY_USAGE_CHECKED_VALUE = 32.cint
GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE = 64.cint
GODOT_PROPERTY_USAGE_GROUP_VALUE = 128.cint
GODOT_PROPERTY_USAGE_CATEGORY_VALUE = 256.cint
GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE = 512.cint
GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE = 1024.cint
GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE = 2048.cint
GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE = 4096.cint
GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE = 8192.cint
GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE = 16384.cint
GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE = 32768.cint
GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE = 65536.cint
proc getClassConstructor*(className: cstring): GodotClassConstructor
{.inline.} =
getGDNativeAPI().getClassConstructor(className)
GODOT_PROPERTY_USAGE_DEFAULT_VALUE: cint =
GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_EDITOR_VALUE or
GODOT_PROPERTY_USAGE_NETWORK_VALUE
GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE: cint =
GODOT_PROPERTY_USAGE_STORAGE_VALUE or
GODOT_PROPERTY_USAGE_EDITOR_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE or
GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
GODOT_PROPERTY_USAGE_NOEDITOR_VALUE: cint =
GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE
type
GodotPropertyUsage* {.size: sizeof(cint), pure.} = enum
Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE
Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE
Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE
NoEditor = GODOT_PROPERTY_USAGE_NOEDITOR_VALUE
Default = GODOT_PROPERTY_USAGE_DEFAULT_VALUE
EditorHelper = GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE
Checkable = GODOT_PROPERTY_USAGE_CHECKABLE_VALUE
## used for editing global variables
Checked = GODOT_PROPERTY_USAGE_CHECKED_VALUE
## used for editing global variables
Internationalized = GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
## hint for internationalized strings
DefaultIntl = GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE
Group = GODOT_PROPERTY_USAGE_GROUP_VALUE
## used for grouping props in the editor
Category = GODOT_PROPERTY_USAGE_CATEGORY_VALUE
NonZero = GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE
## only store if nonzero
NonOne = GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE
## only store if false
NoInstanceState = GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE
RestartIfChanged = GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE
ScriptVariable = GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE
StoreIfNull = GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE
AnimateAsTrigger = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE
UpdateAllIfModified = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE
GodotPropertyAttributes* {.bycopy.} = object
rsetType*: GodotMethodRPCMode
typ*: cint
hint*: GodotPropertyHint
hintString*: GodotString
usage*: cint
defaultValue*: GodotVariant
GodotInstanceCreateFunc* {.bycopy.} = object
createFunc*:
proc (obj: ptr GodotObject; methodData: pointer): pointer {.noconv.}
## returns user data
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotInstanceDestroyFunc* {.bycopy.} = object
destroyFunc*:
proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer) {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
proc godotScriptRegisterClass*(libHandle: pointer; name, base: cstring;
create_func: GodotInstanceCreateFunc;
destroy_func: GodotInstanceDestroyFunc) {.
importc: "godot_nativescript_register_class".}
proc godotScriptRegisterToolClass*(libHandle: pointer; name, base: cstring;
createFunc: GodotInstanceCreateFunc;
destroyFunc: GodotInstanceDestroyFunc) {.
importc: "godot_nativescript_register_tool_class".}
type
GodotInstanceMethod* {.bycopy.} = object
meth*:
proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer; numArgs: cint;
args: var array[MAX_ARG_COUNT, ptr GodotVariant]):
GodotVariant {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
proc godotScriptRegisterMethod*(libHandle: pointer;
name: cstring; function_name: cstring;
attr: GodotMethodAttributes;
meth: GodotInstanceMethod) {.
importc: "godot_nativescript_register_method".}
type
GodotPropertySetFunc* {.bycopy.} = object
setFunc*: proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer; value: GodotVariant) {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotPropertyGetFunc* {.bycopy.} = object
getFunc*: proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer): GodotVariant {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
proc godotScriptRegisterProperty*(libHandle: pointer;
name: cstring; path: cstring;
attr: ptr GodotPropertyAttributes;
setFunc: GodotPropertySetFunc;
getFunc: GodotPropertyGetFunc) {.
importc: "godot_nativescript_register_property".}
type
GodotSignalArgument* {.bycopy.} = object
name*: GodotString
typ*: cint
hint*: GodotPropertyHint
hintString*: GodotString
usage*: cint
defaultValue*: GodotVariant
GodotSignal* = object
name*: GodotString
numArgs*: cint
args*: ptr GodotSignalArgument
numDefaultArgs*: cint
defaultArgs*: ptr GodotVariant
proc godotScriptRegisterSignal*(libHandle: pointer; name: cstring;
signal: GodotSignal) {.
importc: "godot_nativescript_register_signal".}
proc getUserdata*(instance: ptr GodotObject): pointer {.
importc: "godot_nativescript_get_userdata".}
type ClassConstructor = proc (): ptr GodotObject {.noconv.}
proc getClassConstructor*(className: cstring): ClassConstructor {.
importc: "godot_get_class_constructor".}
proc deinit*(o: ptr GodotObject) {.
importc: "godot_object_destroy".}
proc deinit*(o: ptr GodotObject) {.inline.} =
getGDNativeAPI().objectDestroy(o)
# print using Godot's error handler list
proc godotPrintError*(description: cstring; function: cstring; file: cstring;
line: cint) {.
importc: "godot_print_error".}
proc godotPrintError*(description, function, file: cstring;
line: cint) {.inline.} =
let api = getGDNativeAPI()
api.printError(description, function, file, line)
proc godotPrintWarning*(description: cstring; function: cstring;
file: cstring; line: cint) {.
importc: "godot_print_warning".}
proc godotPrintWarning*(description, function, file: cstring;
line: cint) {.inline.} =
getGDNativeAPI().printWarning(description, function, file, line)
proc godotPrint*(message: GodotString) {.
importc: "godot_print".}
proc godotPrint*(message: GodotString) {.inline.} =
getGDNativeAPI().print(message)
var getClassMethodBind: ptr GodotMethodBind
proc getClassName*(o: ptr GodotObject): string =
@ -267,22 +95,25 @@ proc getClassName*(o: ptr GodotObject): string =
# There are physics type not known by ClassDB
result = result[0..result.len-3]
proc getGodotSingleton*(name: cstring): ptr GodotObject {.
importc: "godot_global_get_singleton".}
proc getGodotSingleton*(name: cstring): ptr GodotObject {.inline.} =
getGDNativeAPI().globalGetSingleton(name)
# System Functions
proc godotAlloc*(bytes: cint): pointer {.
importc: "godot_alloc".}
proc godotAlloc*(bytes: cint): pointer {.inline.} =
## 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".}
getGDNativeAPI().alloc(bytes)
proc godotRealloc*(p: pointer; bytes: cint): pointer {.inline.} =
## 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".}
getGDNativeAPI().realloc(p, bytes)
proc godotFree*(p: pointer) {.inline.} =
## 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.
getGDNativeAPI().free(p)

197
godot/internal/godotarrays.nim
View file

@ -1,107 +1,130 @@
# Copyright (c) 2017 Xored Software, Inc.
type
GodotArray* {.byref.} = object
data: array[sizeof(int), byte]
import godotinternaltypes, gdnativeapi, core.godotcoretypes
proc len*(self: GodotArray): cint {.
noSideEffect,
importc: "godot_array_size".}
proc len*(self: GodotArray): cint {.inline.} =
getGDNativeAPI().arraySize(self)
import hashes
import godotobjects, 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 initGodotArray*(dest: var GodotArray) {.inline.} =
getGDNativeAPI().arrayNew(dest)
proc deinit*(self: var GodotArray) {.importc: "godot_array_destroy".}
proc initGodotArray*(dest: var GodotArray;
pca: GodotPoolColorArray) {.inline.} =
getGDNativeAPI().arrayNewPoolColorArray(dest, pca)
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 initGodotArray*(dest: var GodotArray;
pv3a: GodotPoolVector3Array) {.inline.} =
getGDNativeAPI().arrayNewPoolVector3Array(dest, pv3a)
proc initGodotArray*(dest: var GodotArray;
pv2a: GodotPoolVector2Array) {.inline.} =
getGDNativeAPI().arrayNewPoolVector2Array(dest, pv2a)
proc initGodotArray*(dest: var GodotArray;
psa: GodotPoolStringArray) {.inline.} =
getGDNativeAPI().arrayNewPoolStringArray(dest, psa)
proc initGodotArray*(dest: var GodotArray;
pra: GodotPoolRealArray) {.inline.} =
getGDNativeAPI().arrayNewPoolRealArray(dest, pra)
proc initGodotArray*(dest: var GodotArray;
pia: GodotPoolIntArray) {.inline.} =
getGDNativeAPI().arrayNewPoolIntArray(dest, pia)
proc initGodotArray*(dest: var GodotArray;
pba: GodotPoolByteArray) {.inline.} =
getGDNativeAPI().arrayNewPoolByteArray(dest, pba)
proc initGodotArray*(dest: var GodotArray; src: GodotArray) {.inline.} =
getGDNativeAPI().arrayNewCopy(dest, src)
proc deinit*(self: var GodotArray) {.inline.} =
getGDNativeAPI().arrayDestroy(self)
proc `[]=`*(self: var GodotArray; idx: cint; value: GodotVariant) {.inline.} =
getGDNativeAPI().arraySet(self, idx, value)
proc `[]`*(self: GodotArray; idx: cint): GodotVariant {.inline.} =
getGDNativeAPI().arrayGet(self, idx)
proc mget*(self: var GodotArray; idx: cint): ptr GodotVariant {.inline.} =
getGDNativeAPI().arrayOperatorIndex(self, idx)
proc add*(self: var GodotArray; value: GodotVariant) {.inline.} =
getGDNativeAPI().arrayPushBack(self, value)
proc clear*(self: var GodotArray) {.inline.} =
getGDNativeAPI().arrayClear(self)
proc count*(self: GodotArray; value: GodotVariant): cint {.inline.} =
getGDNativeAPI().arrayCount(self, value)
proc isEmpty*(self: GodotArray): bool {.inline.} =
getGDNativeAPI().arrayEmpty(self)
proc erase*(self: var GodotArray; value: GodotVariant) {.inline.} =
getGDNativeAPI().arrayErase(self, value)
proc first*(self: GodotArray): GodotVariant {.inline.} =
getGDNativeAPI().arrayFront(self)
proc last*(self: GodotArray): GodotVariant {.inline.} =
getGDNativeAPI().arrayBack(self)
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".}
fromIdx: cint): cint {.inline.} =
getGDNativeAPI().arrayFind(self, what, fromIdx)
proc findLast*(self: GodotArray; what: GodotVariant): cint {.inline.} =
getGDNativeAPI().arrayFindLast(self, what)
proc contains*(self: GodotArray; value: GodotVariant): bool {.inline.} =
getGDNativeAPI().arrayHas(self, value)
proc godotHash*(self: GodotArray): cint {.inline.} =
getGDNativeAPI().arrayHash(self)
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".}
value: GodotVariant): Error {.discardable, inline.} =
getGDNativeAPI().arrayInsert(self, pos, value)
proc reverse*(self: var GodotArray) {.inline.} =
getGDNativeAPI().arrayInvert(self)
proc popLast*(self: var GodotArray): GodotVariant {.inline.} =
getGDNativeAPI().arrayPopBack(self)
proc popFirst*(self: var GodotArray): GodotVariant {.inline.} =
getGDNativeAPI().arrayPopFront(self)
proc addLast*(self: var GodotArray; value: GodotVariant) {.inline.} =
getGDNativeAPI().arrayPushBack(self, value)
proc addFirst*(self: var GodotArray; value: GodotVariant) {.inline.} =
getGDNativeAPI().arrayPushFront(self, value)
proc delete*(self: var GodotArray; idx: cint) {.inline.} =
getGDNativeAPI().arrayRemove(self, idx)
proc setLen*(self: var GodotArray; size: cint) {.inline.} =
getGDNativeAPI().arrayResize(self, size)
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 sort*(self: var GodotArray) {.importc: "godot_array_sort".}
proc sortCustom*(self: var GodotArray; obj: var GodotObject;
funcName: GodotString) {.
importc: "godot_array_sort_custom".}
fromIdx: cint): cint {.inline.} =
getGDNativeAPI().arrayRFind(self, what, fromIdx)
proc sort*(self: var GodotArray) {.inline.} =
getGDNativeAPI().arraySort(self)
proc sortCustom*(self: var GodotArray; obj: ptr GodotObject;
funcName: GodotString) {.inline.} =
getGDNativeAPI().arraySortCustom(self, obj, funcName)
iterator items*(self: GodotArray): GodotVariant =
for i in 0..<self.len:

84
godot/internal/godotdictionaries.nim
View file

@ -1,48 +1,56 @@
# Copyright (c) 2017 Xored Software, Inc.
type
GodotDictionary* {.byref.} = object
data: array[sizeof(int), byte]
import godotinternaltypes, gdnativeapi
import godotarrays, godotvariants, godotstrings
proc initGodotDictionary*(dest: var GodotDictionary) {.inline.} =
getGDNativeAPI().dictionaryNew(dest)
proc initGodotDictionary*(dest: var GodotDictionary; src: GodotDictionary) {.
importc: "godot_dictionary_new_copy".}
proc initGodotDictionary*(dest: var GodotDictionary;
src: GodotDictionary) {.inline.} =
getGDNativeAPI().dictionaryNewCopy(dest, src)
proc deinit*(self: var GodotDictionary) {.
importc: "godot_dictionary_destroy".}
proc deinit*(self: var GodotDictionary) {.inline.} =
getGDNativeAPI().dictionaryDestroy(self)
proc initGodotDictionary*(dest: var GodotDictionary) {.
importc: "godot_dictionary_new".}
proc len*(self: GodotDictionary): cint {.inline.} =
getGDNativeAPI().dictionarySize(self)
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 isEmpty*(self: GodotDictionary): bool {.inline.} =
getGDNativeAPI().dictionaryEmpty(self)
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 clear*(self: var GodotDictionary) {.inline.} =
getGDNativeAPI().dictionaryClear(self)
proc `==`*(self, other: GodotDictionary): bool {.
importc: "godot_dictionary_operator_equal".}
proc contains*(self: GodotDictionary; key: GodotVariant): bool {.inline.} =
getGDNativeAPI().dictionaryHas(self, key)
proc toJson*(self: GodotDictionary): GodotString {.
importc: "godot_dictionary_to_json".}
proc contains*(self: GodotDictionary; keys: GodotArray): bool {.inline.} =
getGDNativeAPI().dictionaryHasAll(self, keys)
proc del*(self: var GodotDictionary; key: GodotVariant) {.inline.} =
getGDNativeAPI().dictionaryErase(self, key)
proc godotHash*(self: GodotDictionary): cint {.inline.} =
getGDNativeAPI().dictionaryHash(self, )
proc keys*(self: GodotDictionary): GodotArray {.inline.} =
getGDNativeAPI().dictionaryKeys(self)
proc values*(self: GodotDictionary): GodotArray {.inline.} =
getGDNativeAPI().dictionaryValues(self)
proc `[]`*(self: GodotDictionary; key: GodotVariant): GodotVariant {.inline.} =
getGDNativeAPI().dictionaryGet(self, key)
proc `[]=`*(self: var GodotDictionary; key, value: GodotVariant) {.inline.} =
getGDNativeAPI().dictionarySet(self, key, value)
proc mget*(self: var GodotDictionary;
key: GodotVariant): ptr GodotVariant {.inline.} =
getGDNativeAPI().dictionaryOperatorIndex(self, key)
proc `==`*(self, other: GodotDictionary): bool {.inline.} =
getGDNativeAPI().dictionaryOperatorEqual(self, other)
proc toJson*(self: GodotDictionary): GodotString {.inline.} =
getGDNativeAPI().dictionaryToJson(self)

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

@ -0,0 +1,262 @@
# Copyright 2017 Xored Software, Inc.
const MAX_ARG_COUNT* = 256
type
GodotArray* {.byref.} = object
data: array[sizeof(int), byte]
GodotDictionary* {.byref.} = object
data: array[sizeof(int), byte]
GodotNodePath* {.byref.} = object
data: array[sizeof(int), byte]
GodotObject* = object
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]
GodotString* {.byref.} = object
data: array[sizeof(int), byte]
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
GodotVariant* {.byref.} = object
data: array[4 + sizeof(int) div 4, float32]
type GodotMethodBind* = object
type
GodotNativeInitOptions* = object
inEditor*: bool
coreApiHash*: uint64
editorApiHash*: uint64
noApiHash*: uint64
gdNativeLibrary*: ptr GodotObject
gdNativeAPIStruct*: pointer
activeLibraryPath*: ptr GodotString
GodotNativeTerminateOptions* = object
inEditor*: bool
GodotMethodRPCMode* {.size: sizeof(cint), pure.} = enum
Disabled,
Remote,
Sync,
Master,
Slave
GodotMethodAttributes* = object
rpcMode*: GodotMethodRPCMode
GodotPropertyHint* {.size: sizeof(cint), pure.} = enum
None, ## no hint provided.
Range, ## hint_text = "min,max,step,slider; // slider is optional"
ExpRange, ## hint_text = "min,max,step", exponential edit
Enum, ## hint_text= "val1,val2,val3,etc"
ExpEasing, ## exponential easing funciton (Math::ease)
Length, ## hint_text= "length" (as integer)
SpriteFrame,
KeyAccel, ## hint_text= "length" (as integer)
Flags, ## hint_text= "flag1,flag2,etc" (as bit flags)
Layers2DRender,
Layers2DPhysics,
Layers3DRender,
Layers3DPhysics,
File, ## a file path must be passed, hint_text (optionally)
## is a filter "*.png,*.wav,*.doc,"
Dir, ## a directort path must be passed
GlobalFile, ## a file path must be passed, hint_text (optionally) is a
## filter "*.png,*.wav,*.doc,"
GlobalDir, ## a directort path must be passed
ResourceType, ## a resource object type
MultilineText, ## used for string properties that can contain multiple lines
ColorNoAlpha, ## used for ignoring alpha component when editing a color
ImageCompressLossy,
ImageCompressLossless,
ObjectId,
TypeString, ## a type string, the hint is the base type to choose
NodePathToEditedNode, ## so something else can provide this
## (used in scripts)
MethodOfVariantType, ## a method of a type
MethodOfBaseType, ## a method of a base type
MethodOfInstance, ## a method of an instance
MethodOfScript, ## a method of a script & base
PropertyOfVariantType, ## a property of a type
PropertyOfBaseType, ## a property of a base type
PropertyOfInstance, ## a property of an instance
PropertyOfScript, ## a property of a script & base
PropertyHintMax
const
GODOT_PROPERTY_USAGE_STORAGE_VALUE = 1.cint
GODOT_PROPERTY_USAGE_EDITOR_VALUE = 2.cint
GODOT_PROPERTY_USAGE_NETWORK_VALUE = 4.cint
GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE = 8.cint
GODOT_PROPERTY_USAGE_CHECKABLE_VALUE = 16.cint
GODOT_PROPERTY_USAGE_CHECKED_VALUE = 32.cint
GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE = 64.cint
GODOT_PROPERTY_USAGE_GROUP_VALUE = 128.cint
GODOT_PROPERTY_USAGE_CATEGORY_VALUE = 256.cint
GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE = 512.cint
GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE = 1024.cint
GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE = 2048.cint
GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE = 4096.cint
GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE = 8192.cint
GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE = 16384.cint
GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE = 32768.cint
GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE = 65536.cint
GODOT_PROPERTY_USAGE_DEFAULT_VALUE: cint =
GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_EDITOR_VALUE or
GODOT_PROPERTY_USAGE_NETWORK_VALUE
GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE: cint =
GODOT_PROPERTY_USAGE_STORAGE_VALUE or
GODOT_PROPERTY_USAGE_EDITOR_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE or
GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
GODOT_PROPERTY_USAGE_NOEDITOR_VALUE: cint =
GODOT_PROPERTY_USAGE_STORAGE_VALUE or GODOT_PROPERTY_USAGE_NETWORK_VALUE
type
GodotPropertyUsage* {.size: sizeof(cint), pure.} = enum
Storage = GODOT_PROPERTY_USAGE_STORAGE_VALUE
Editor = GODOT_PROPERTY_USAGE_EDITOR_VALUE
Network = GODOT_PROPERTY_USAGE_NETWORK_VALUE
NoEditor = GODOT_PROPERTY_USAGE_NOEDITOR_VALUE
Default = GODOT_PROPERTY_USAGE_DEFAULT_VALUE
EditorHelper = GODOT_PROPERTY_USAGE_EDITOR_HELPER_VALUE
Checkable = GODOT_PROPERTY_USAGE_CHECKABLE_VALUE
## used for editing global variables
Checked = GODOT_PROPERTY_USAGE_CHECKED_VALUE
## used for editing global variables
Internationalized = GODOT_PROPERTY_USAGE_INTERNATIONALIZED_VALUE
## hint for internationalized strings
DefaultIntl = GODOT_PROPERTY_USAGE_DEFAULT_INTL_VALUE
Group = GODOT_PROPERTY_USAGE_GROUP_VALUE
## used for grouping props in the editor
Category = GODOT_PROPERTY_USAGE_CATEGORY_VALUE
NonZero = GODOT_PROPERTY_USAGE_STORE_IF_NONZERO_VALUE
## only store if nonzero
NonOne = GODOT_PROPERTY_USAGE_STORE_IF_NONONE_VALUE
## only store if false
NoInstanceState = GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE_VALUE
RestartIfChanged = GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED_VALUE
ScriptVariable = GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE_VALUE
StoreIfNull = GODOT_PROPERTY_USAGE_STORE_IF_NULL_VALUE
AnimateAsTrigger = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER_VALUE
UpdateAllIfModified = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED_VALUE
GodotPropertyAttributes* {.bycopy.} = object
rsetType*: GodotMethodRPCMode
typ*: cint
hint*: GodotPropertyHint
hintString*: GodotString
usage*: cint
defaultValue*: GodotVariant
GodotInstanceCreateFunc* {.bycopy.} = object
createFunc*:
proc (obj: ptr GodotObject; methodData: pointer): pointer {.noconv.}
## returns user data
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotInstanceDestroyFunc* {.bycopy.} = object
destroyFunc*:
proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer) {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotInstanceMethod* {.bycopy.} = object
meth*:
proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer; numArgs: cint;
args: var array[MAX_ARG_COUNT, ptr GodotVariant]):
GodotVariant {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotPropertySetFunc* {.bycopy.} = object
setFunc*: proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer; value: GodotVariant) {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotPropertyGetFunc* {.bycopy.} = object
getFunc*: proc (obj: ptr GodotObject; methodData: pointer;
userData: pointer): GodotVariant {.noconv.}
methodData*: pointer
freeFunc*: proc (a2: pointer) {.noconv.}
GodotSignalArgument* {.bycopy.} = object
name*: GodotString
typ*: cint
hint*: GodotPropertyHint
hintString*: GodotString
usage*: cint
defaultValue*: GodotVariant
GodotSignal* = object
name*: GodotString
numArgs*: cint
args*: ptr GodotSignalArgument
numDefaultArgs*: cint
defaultArgs*: ptr GodotVariant
GodotClassConstructor* = proc (): ptr GodotObject {.noconv.}

60
godot/internal/godotnodepaths.nim
View file

@ -1,32 +1,40 @@
# Copyright 2017 Xored Software, Inc.
import godotstrings
import godotinternaltypes, gdnativeapi
type
GodotNodePath* {.byref.} = object
data: array[sizeof(int), byte]
proc initGodotNodePath*(dest: var GodotNodePath; s: GodotString) {.inline.} =
getGDNativeAPI().nodePathNew(dest, s)
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 initGodotNodePath*(dest: var GodotNodePath;
src: GodotNodePath) {.inline.} =
getGDNativeAPI().nodePathNewCopy(dest, src)
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 deinit*(self: var GodotNodePath) {.inline.} =
getGDNativeAPI().nodePathDestroy(self)
proc `==`*(a, b: GodotNodePath): bool {.
noSideEffect, importc: "godot_node_path_operator_equal".}
proc toGodotString*(self: GodotNodePath): GodotString {.inline.} =
getGDNativeAPI().nodePathAsString(self)
proc isAbsolute*(self: GodotNodePath): bool {.inline.} =
getGDNativeAPI().nodePathIsAbsolute(self)
proc nameCount*(self: GodotNodePath): cint {.inline.} =
getGDNativeAPI().nodePathGetNameCount(self)
proc getName*(self: GodotNodePath; idx: cint): GodotString {.inline.} =
getGDNativeAPI().nodePathGetName(self, idx)
proc subnameCount*(self: GodotNodePath): cint {.inline.} =
getGDNativeAPI().nodePathGetSubnameCount(self)
proc getSubname*(self: GodotNodePath; idx: cint): GodotString {.inline.} =
getGDNativeAPI().nodePathGetSubname(self, idx)
proc property*(self: GodotNodePath): GodotString {.inline.} =
getGDNativeAPI().nodePathGetProperty(self)
proc isEmpty*(self: GodotNodePath): bool {.inline.} =
getGDNativeAPI().nodePathIsEmpty(self)
proc `==`*(a, b: GodotNodePath): bool {.inline.} =
getGDNativeAPI().nodePathOperatorEqual(a, b)

4
godot/internal/godotobjects.nim
View file

@ -1,4 +0,0 @@
# Copyright 2017 Xored Software, Inc.
type
GodotObject* = object

495
godot/internal/godotpoolarrays.nim
View file

@ -1,374 +1,169 @@
# 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 godotinternaltypes, gdnativeapi
import core.godotcoretypes
import godotstrings, godotarrays
import core.godotbase, core.colors, core.vector2, core.vector3
template genPoolArrayAPI(ArrayT, initIdent, DataT,
newProc, newCopyProc, newWithArrayProc, appendProc,
appendArrayProc, insertProc, invertProc, pushBackProc,
removeProc, resizeProc, setProc, getProc, sizeProc,
destroyProc) =
proc initIdent*(dest: var ArrayT) {.inline.} =
getGDNativeAPI().newProc(dest)
# byte
proc initIdent*(dest: var ArrayT; src: ArrayT) {.inline.} =
getGDNativeAPI().newCopyProc(dest, src)
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 initIdent*(dest: var ArrayT; arr: GodotArray) {.inline.} =
getGDNativeAPI().newWithArrayProc(dest, arr)
proc deinit*(self: var GodotPoolByteArray) {.
importc: "godot_pool_byte_array_destroy".}
proc deinit*(self: var ArrayT) {.inline.} =
getGDNativeAPI().destroyProc(self)
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 add*(self: var ArrayT; data: DataT) {.inline.} =
getGDNativeAPI().pushBackProc(self, data)
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 add*(self: var ArrayT; arr: ArrayT) {.inline.} =
getGDNativeAPI().appendArrayProc(self, arr)
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".}
proc insert*(self: var ArrayT; idx: cint;
data: DataT): Error {.inline.} =
getGDNativeAPI().insertProc(self, idx, data)
iterator items*(arr: GodotPoolByteArray): byte =
for i in 0..<arr.len:
yield arr[i]
proc delete*(self: var ArrayT; idx: cint) {.inline.} =
getGDNativeAPI().removeProc(self, idx)
iterator pairs*(arr: GodotPoolByteArray): tuple[key: cint, val: byte] =
for i in 0..<arr.len:
yield (i, arr[i])
proc reverse*(self: var ArrayT) {.inline.} =
getGDNativeAPI().invertProc(self)
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 setLen*(self: var ArrayT; size: cint) {.inline.} =
getGDNativeAPI().resizeProc(self, size)
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 `[]=`*(self: var ArrayT; idx: cint; data: DataT) {.inline.} =
getGDNativeAPI().setProc(self, idx, data)
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".}
proc `[]`*(self: ArrayT; idx: cint): DataT {.inline.} =
getGDNativeAPI().getProc(self, idx)
iterator items*(arr: GodotPoolIntArray): cint =
for i in 0..<arr.len:
yield arr[i]
proc len*(self: ArrayT): cint {.inline.} =
getGDNativeAPI().sizeProc(self)
iterator pairs*(arr: GodotPoolIntArray): tuple[key: cint, val: cint] =
for i in 0..<arr.len:
yield (i, arr[i])
iterator items*(arr: ArrayT): DataT =
for i in 0..<arr.len:
yield arr[i]
# Real
iterator pairs*(arr: ArrayT): tuple[key: cint, val: DataT] =
for i in 0..<arr.len:
yield (i, arr[i])
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".}
genPoolArrayAPI(GodotPoolByteArray, initGodotPoolByteArray, byte,
poolByteArrayNew,
poolByteArrayNewCopy,
poolByteArrayNewWithArray,
poolByteArrayAppend,
poolByteArrayAppendArray,
poolByteArrayInsert,
poolByteArrayInvert,
poolByteArrayPushBack,
poolByteArrayRemove,
poolByteArrayResize,
poolByteArraySet,
poolByteArrayGet,
poolByteArraySize,
poolByteArrayDestroy)
proc deinit*(self: var GodotPoolRealArray) {.
importc: "godot_pool_real_array_destroy".}
genPoolArrayAPI(GodotPoolIntArray, initGodotPoolIntArray, cint,
poolIntArrayNew,
poolIntArrayNewCopy,
poolIntArrayNewWithArray,
poolIntArrayAppend,
poolIntArrayAppendArray,
poolIntArrayInsert,
poolIntArrayInvert,
poolIntArrayPushBack,
poolIntArrayRemove,
poolIntArrayResize,
poolIntArraySet,
poolIntArrayGet,
poolIntArraySize,
poolIntArrayDestroy)
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".}
genPoolArrayAPI(GodotPoolRealArray, initGodotPoolRealArray, float32,
poolRealArrayNew,
poolRealArrayNewCopy,
poolRealArrayNewWithArray,
poolRealArrayAppend,
poolRealArrayAppendArray,
poolRealArrayInsert,
poolRealArrayInvert,
poolRealArrayPushBack,
poolRealArrayRemove,
poolRealArrayResize,
poolRealArraySet,
poolRealArrayGet,
poolRealArraySize,
poolRealArrayDestroy)
iterator items*(arr: GodotPoolRealArray): float32 =
for i in 0..<arr.len:
yield arr[i]
genPoolArrayAPI(GodotPoolStringArray, initGodotPoolStringArray, GodotString,
poolStringArrayNew,
poolStringArrayNewCopy,
poolStringArrayNewWithArray,
poolStringArrayAppend,
poolStringArrayAppendArray,
poolStringArrayInsert,
poolStringArrayInvert,
poolStringArrayPushBack,
poolStringArrayRemove,
poolStringArrayResize,
poolStringArraySet,
poolStringArrayGet,
poolStringArraySize,
poolStringArrayDestroy)
iterator pairs*(arr: GodotPoolRealArray): tuple[key: cint, val: float32] =
for i in 0..<arr.len:
yield (i, arr[i])
genPoolArrayAPI(GodotPoolVector2Array, initGodotPoolVector2Array, Vector2,
poolVector2ArrayNew,
poolVector2ArrayNewCopy,
poolVector2ArrayNewWithArray,
poolVector2ArrayAppend,
poolVector2ArrayAppendArray,
poolVector2ArrayInsert,
poolVector2ArrayInvert,
poolVector2ArrayPushBack,
poolVector2ArrayRemove,
poolVector2ArrayResize,
poolVector2ArraySet,
poolVector2ArrayGet,
poolVector2ArraySize,
poolVector2ArrayDestroy)
# String
genPoolArrayAPI(GodotPoolVector3Array, initGodotPoolVector3Array, Vector3,
poolVector3ArrayNew,
poolVector3ArrayNewCopy,
poolVector3ArrayNewWithArray,
poolVector3ArrayAppend,
poolVector3ArrayAppendArray,
poolVector3ArrayInsert,
poolVector3ArrayInvert,
poolVector3ArrayPushBack,
poolVector3ArrayRemove,
poolVector3ArrayResize,
poolVector3ArraySet,
poolVector3ArrayGet,
poolVector3ArraySize,
poolVector3ArrayDestroy)
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])
genPoolArrayAPI(GodotPoolColorArray, initGodotPoolColorArray, Color,
poolColorArrayNew,
poolColorArrayNewCopy,
poolColorArrayNewWithArray,
poolColorArrayAppend,
poolColorArrayAppendArray,
poolColorArrayInsert,
poolColorArrayInvert,
poolColorArrayPushBack,
poolColorArrayRemove,
poolColorArrayResize,
poolColorArraySet,
poolColorArrayGet,
poolColorArraySize,
poolColorArrayDestroy)

41
godot/internal/godotstrings.nim
View file

@ -1,35 +1,38 @@
# Copyright (c) 2017 Xored Software, Inc.
type
GodotString* {.byref.} = object
data: array[sizeof(int), byte]
import godotinternaltypes, gdnativeapi
proc initGodotString(dest: var GodotString) {.inline, raises: [].} =
getGDNativeAPI().stringNew(dest)
proc initGodotString(dest: var GodotString) {.
importc: "godot_string_new".}
proc initGodotString(dest: var GodotString; contents: cstring;
size: cint) {.
importc: "godot_string_new_data".}
size: cint) {.inline.} =
## Initializes ``dest`` from UTF-8 ``contents``
getGDNativeAPI().stringNewData(dest, contents, size)
proc getData(self: GodotString; dest: cstring;
size: var cint) {.
noSideEffect
importc: "godot_string_get_data".}
size: var cint) {.inline.} =
## Converts ``self`` into UTF-8 encoding, putting the result into ``dest``.
getGDNativeAPI().stringGetData(self, dest, size)
proc len*(self: GodotString): cint {.inline.} =
## Returns the length of string in bytes if it is represented as UTF-8.
getData(self, nil, result)
proc cstring*(self: GodotString): cstring {.
importc: "godot_string_c_str".}
proc `==`*(self, b: GodotString): bool {.
importc: "godot_string_operator_equal".}
proc `<`*(self, b: GodotString): bool {.
importc: "godot_string_operator_less".}
proc `&`*(self, b: GodotString): GodotString {.
importc: "godot_string_operator_plus".}
proc cstring*(self: GodotString): cstring {.inline.} =
getGDNativeAPI().stringCStr(self)
proc deinit*(self: var GodotString) {.importc: "godot_string_destroy".}
proc `==`*(self, b: GodotString): bool {.inline.} =
getGDNativeAPI().stringOperatorEqual(self, b)
proc `<`*(self, b: GodotString): bool {.inline.} =
getGDNativeAPI().stringOperatorLess(self, b)
proc `&`*(self, b: GodotString): GodotString {.inline.} =
getGDNativeAPI().stringOperatorPlus(self, b)
proc deinit*(self: var GodotString) {.inline.} =
getGDNativeAPI().stringDestroy(self)
proc `$`*(self: GodotString): string =
## Converts the ``GodotString`` into Nim string

379
godot/internal/godotvariants.nim
View file

@ -1,197 +1,216 @@
# 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
import core.godotcoretypes, godotinternaltypes, gdnativeapi
VariantCallErrorType* {.size: sizeof(cint), pure.} = enum
OK,
InvalidMethod,
InvalidArgument,
TooManyArguments,
TooFewArguments,
InstanceIsNull
proc getType*(p: GodotVariant): VariantType {.inline.} =
getGDNativeAPI().variantGetType(p)
VariantCallError* = object
error*: VariantCallErrorType
argument*: cint
expected*: VariantType
proc initGodotVariant*(dest: var GodotVariant) {.inline.} =
getGDNativeAPI().variantNewNil(dest)
GodotVariant* {.byref.} = object
data: array[4 + sizeof(int) div 4, float32]
proc initGodotVariant*(dest: var GodotVariant, src: GodotVariant) {.inline.} =
getGDNativeAPI().variantNewCopy(dest, src)
import godotobjects, godotarrays, godotpoolarrays,
godotstrings, godotnodepaths, godotdictionaries
proc initGodotVariant*(dest: var GodotVariant; b: bool) {.inline.} =
getGDNativeAPI().variantNewBool(dest, b)
import core.vector2, core.rect2,
core.vector3, core.transform2d, core.planes,
core.quats, core.rect3, core.basis,
core.transforms, core.colors, core.rids,
core.rect2
proc initGodotVariant*(dest: var GodotVariant; i: uint64) {.inline.} =
getGDNativeAPI().variantNewUInt(dest, i)
proc getType*(p: GodotVariant): VariantType {.
importc: "godot_variant_get_type".}
proc initGodotVariant*(dest: var GodotVariant; i: int64) {.inline.} =
getGDNativeAPI().variantNewInt(dest, i)
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 initGodotVariant*(dest: var GodotVariant; r: cdouble) {.inline.} =
getGDNativeAPI().variantNewReal(dest, r)
proc deinit*(v: var GodotVariant) {.importc: "godot_variant_destroy".}
proc initGodotVariant*(dest: var GodotVariant; s: GodotString) {.inline.} =
getGDNativeAPI().variantNewString(dest, s)
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 initGodotVariant*(dest: var GodotVariant; v2: Vector2) {.inline.} =
getGDNativeAPI().variantNewVector2(dest, v2)
proc call*(self: GodotVariant; meth: GodotString;
args: var array[128, GodotVariant]; argCount: cint;
error: var VariantCallError): GodotVariant {.
importc: "godot_variant_call".}
proc initGodotVariant*(dest: var GodotVariant; rect2: Rect2) {.inline.} =
getGDNativeAPI().variantNewRect2(dest, rect2)
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".}
proc initGodotVariant*(dest: var GodotVariant; v3: Vector3) {.inline.} =
getGDNativeAPI().variantNewVector3(dest, v3)
proc initGodotVariant*(dest: var GodotVariant; t2d: Transform2D) {.inline.} =
getGDNativeAPI().variantNewTransform2D(dest, t2d)
proc initGodotVariant*(dest: var GodotVariant; plane: Plane) {.inline.} =
getGDNativeAPI().variantNewPlane(dest, plane)
proc initGodotVariant*(dest: var GodotVariant; quat: Quat) {.inline.} =
getGDNativeAPI().variantNewQuat(dest, quat)
proc initGodotVariant*(dest: var GodotVariant; rect3: Rect3) {.inline.} =
getGDNativeAPI().variantNewRect3(dest, rect3)
proc initGodotVariant*(dest: var GodotVariant; basis: Basis) {.inline.} =
getGDNativeAPI().variantNewBasis(dest, basis)
proc initGodotVariant*(dest: var GodotVariant; trans: Transform) {.inline.} =
getGDNativeAPI().variantNewTransform(dest, trans)
proc initGodotVariant*(dest: var GodotVariant; color: Color) {.inline.} =
getGDNativeAPI().variantNewColor(dest, color)
proc initGodotVariant*(dest: var GodotVariant;
nodePath: GodotNodePath) {.inline.} =
getGDNativeAPI().variantNewNodePath(dest, nodePath)
proc initGodotVariant*(dest: var GodotVariant; rid: RID) {.inline.} =
getGDNativeAPI().variantNewRID(dest, rid)
proc initGodotVariant*(dest: var GodotVariant;
obj: ptr GodotObject) {.inline.} =
getGDNativeAPI().variantNewObject(dest, obj)
proc initGodotVariant*(dest: var GodotVariant; arr: GodotArray) {.inline.} =
getGDNativeAPI().variantNewArray(dest, arr)
proc initGodotVariant*(dest: var GodotVariant;
pba: GodotPoolByteArray) {.inline.} =
getGDNativeAPI().variantNewPoolByteArray(dest, pba)
proc initGodotVariant*(dest: var GodotVariant;
pia: GodotPoolIntArray) {.inline.} =
getGDNativeAPI().variantNewPoolIntArray(dest, pia)
proc initGodotVariant*(dest: var GodotVariant;
pra: GodotPoolRealArray) {.inline.} =
getGDNativeAPI().variantNewPoolRealArray(dest, pra)
proc initGodotVariant*(dest: var GodotVariant;
psa: GodotPoolStringArray) {.inline.} =
getGDNativeAPI().variantNewPoolStringArray(dest, psa)
proc initGodotVariant*(dest: var GodotVariant;
pv2a: GodotPoolVector2Array) {.inline.} =
getGDNativeAPI().variantNewPoolVector2Array(dest, pv2a)
proc initGodotVariant*(dest: var GodotVariant;
pv3a: GodotPoolVector3Array) {.inline.} =
getGDNativeAPI().variantNewPoolVector3Array(dest, pv3a)
proc initGodotVariant*(dest: var GodotVariant;
pca: GodotPoolColorArray) {.inline.} =
getGDNativeAPI().variantNewPoolColorArray(dest, pca)
proc initGodotVariant*(dest: var GodotVariant;
dict: GodotDictionary) {.inline.} =
getGDNativeAPI().variantNewDictionary(dest, dict)
proc deinit*(v: var GodotVariant) {.inline.} =
getGDNativeAPI().variantDestroy(v)
proc asBool*(self: GodotVariant): bool {.inline.} =
getGDNativeAPI().variantAsBool(self)
proc asUInt*(self: GodotVariant): uint64 {.inline.} =
getGDNativeAPI().variantAsUInt(self)
proc asInt*(self: GodotVariant): int64 {.inline.} =
getGDNativeAPI().variantAsInt(self)
proc asReal*(self: GodotVariant): cdouble {.inline.} =
getGDNativeAPI().variantAsReal(self)
proc asGodotString*(self: GodotVariant): GodotString {.inline.} =
getGDNativeAPI().variantAsString(self)
proc asVector2*(self: GodotVariant): Vector2 {.inline.} =
getGDNativeAPI().variantAsVector2(self)
proc asRect2*(self: GodotVariant): Rect2 {.inline.} =
getGDNativeAPI().variantAsRect2(self)
proc asVector3*(self: GodotVariant): Vector3 {.inline.} =
getGDNativeAPI().variantAsVector3(self)
proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} =
getGDNativeAPI().variantAsTransform2D(self)
proc asPlane*(self: GodotVariant): Plane {.inline.} =
getGDNativeAPI().variantAsPlane(self)
proc asQuat*(self: GodotVariant): Quat {.inline.} =
getGDNativeAPI().variantAsQuat(self)
proc asRect3*(self: GodotVariant): Rect3 {.inline.} =
getGDNativeAPI().variantAsRect3(self)
proc asBasis*(self: GodotVariant): Basis {.inline.} =
getGDNativeAPI().variantAsBasis(self)
proc asTransform*(self: GodotVariant): Transform {.inline.} =
getGDNativeAPI().variantAsTransform(self)
proc asColor*(self: GodotVariant): Color {.inline.} =
getGDNativeAPI().variantAsColor(self)
proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} =
getGDNativeAPI().variantAsNodePath(self)
proc asRID*(self: GodotVariant): RID {.inline.} =
getGDNativeAPI().variantAsRID(self)
proc asGodotObject*(self: GodotVariant): ptr GodotObject {.inline.} =
getGDNativeAPI().variantAsObject(self)
proc asGodotArray*(self: GodotVariant): GodotArray {.inline.} =
getGDNativeAPI().variantAsArray(self)
proc asGodotPoolByteArray*(self: GodotVariant): GodotPoolByteArray {.inline.} =
getGDNativeAPI().variantAsPoolByteArray(self)
proc asGodotPoolIntArray*(self: GodotVariant): GodotPoolIntArray {.inline.} =
getGDNativeAPI().variantAsPoolIntArray(self)
proc asGodotPoolRealArray*(self: GodotVariant): GodotPoolRealArray {.inline.} =
getGDNativeAPI().variantAsPoolRealArray(self)
proc asGodotPoolStringArray*(self: GodotVariant): GodotPoolStringArray
{.inline.} =
getGDNativeAPI().variantAsPoolStringArray(self)
proc asGodotPoolVector2Array*(self: GodotVariant): GodotPoolVector2Array
{.inline.} =
getGDNativeAPI().variantAsPoolVector2Array(self)
proc asGodotPoolVector3Array*(self: GodotVariant): GodotPoolVector3Array
{.inline.} =
getGDNativeAPI().variantAsPoolVector3Array(self)
proc asGodotPoolColorArray*(self: GodotVariant): GodotPoolColorArray
{.inline.} =
getGDNativeAPI().variantAsPoolColorArray(self)
proc asGodotDictionary*(self: GodotVariant): GodotDictionary {.inline.} =
getGDNativeAPI().variantAsDictionary(self)
proc call*(self: var GodotVariant; meth: GodotString;
args: ptr array[256, ptr GodotVariant]; argCount: cint;
error: var VariantCallError): GodotVariant {.inline.} =
getGDNativeAPI().variantCall(self, meth, args, argCount, error)
proc hasMethod*(self: GodotVariant; meth: GodotString): bool {.inline.} =
getGDNativeAPI().variantHasMethod(self, meth)
proc `==`*(self, other: GodotVariant): bool {.inline.} =
getGDNativeAPI().variantOperatorEqual(self, other)
proc `<`*(self, other: GodotVariant): bool {.inline.} =
getGDNativeAPI().variantOperatorLess(self, other)
proc hashCompare*(self, other: GodotVariant): bool {.inline.} =
getGDNativeAPI().variantHashCompare(self, other)
proc booleanize*(self: GodotVariant): bool {.inline.} =
getGDNativeAPI().variantBooleanize(self)
import godotstrings
proc `$`*(self: GodotVariant): string =
var s = self.asGodotString()
result = $s

28
godot/nim/godotmacros.nim
View file

@ -349,11 +349,11 @@ template registerGodotClass(classNameIdent, classNameLit; isRefClass: bool;
)
registerClass(classNameIdent, classNameLit, false)
when isTool:
godotScriptRegisterToolClass(getNativeLibHandle(), classNameLit, baseNameLit,
createFuncObj, destroyFuncObj)
nativeScriptRegisterToolClass(getNativeLibHandle(), classNameLit,
baseNameLit, createFuncObj, destroyFuncObj)
else:
godotScriptRegisterClass(getNativeLibHandle(), classNameLit, baseNameLit,
createFuncObj, destroyFuncObj)
nativeScriptRegisterClass(getNativeLibHandle(), classNameLit,
baseNameLit, createFuncObj, destroyFuncObj)
template registerGodotField(classNameLit, classNameIdent, propNameLit,
propNameIdent, propTypeLit, propTypeIdent,
@ -415,8 +415,8 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit,
{.push warning[ProveInit]: on.}
when hasDefaultValue:
attr.defaultValue = (defaultValueNode).toVariant().godotVariant[]
godotScriptRegisterProperty(getNativeLibHandle(), classNameLit, propNameLit,
unsafeAddr attr, setFunc, getFunc)
nativeScriptRegisterProperty(getNativeLibHandle(), classNameLit, propNameLit,
unsafeAddr attr, setFunc, getFunc)
hintStrGodot.deinit()
static:
@ -568,8 +568,8 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
let meth = GodotInstanceMethod(
meth: methFuncIdent
)
godotScriptRegisterMethod(getNativeLibHandle(), classNameLit, methodNameLit,
GodotMethodAttributes(), meth)
nativeScriptRegisterMethod(getNativeLibHandle(), classNameLit,
methodNameLit, GodotMethodAttributes(), meth)
for meth in obj.methods:
if meth.isNoGodot: continue
@ -605,12 +605,12 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
let refDec = GodotInstanceMethod(
meth: refcountDecremented
)
godotScriptRegisterMethod(getNativeLibHandle(), classNameLit,
cstring"_refcount_incremented",
GodotMethodAttributes(), refInc)
godotScriptRegisterMethod(getNativeLibHandle(), classNameLit,
cstring"_refcount_decremented",
GodotMethodAttributes(), refDec)
nativeScriptRegisterMethod(getNativeLibHandle(), classNameLit,
cstring"_refcount_incremented",
GodotMethodAttributes(), refInc)
nativeScriptRegisterMethod(getNativeLibHandle(), classNameLit,
cstring"_refcount_decremented",
GodotMethodAttributes(), refDec)
result.add(getAst(registerRefIncDec(classNameLit)))
{.push warning[Deprecated]: off.}

10
godot/nim/godotnim.nim
View file

@ -1,7 +1,8 @@
# Copyright 2017 Xored Software, Inc.
import tables, typetraits, macros, asyncdispatch
import core.godotbase
import gdnativeapi
import core.godotcoretypes
import core.vector2, core.rect2,
core.vector3, core.transform2d,
core.planes, core.quats, core.rect3,
@ -94,12 +95,12 @@ proc isFinalized*(obj: NimGodotObject): bool {.inline.} =
template printWarning*(warning: typed) =
## Prints ``warning`` to Godot log, adding filename and line information.
let (filename, line) = instantiationInfo()
godotPrintWarning(cstring($warning), nil, cstring(filename), line.cint)
godotPrintWarning(cstring($warning), cstring"", cstring(filename), line.cint)
template printError*(error: typed) =
## Prints ``error`` to Godot log, adding filename and line information.
let (filename, line) = instantiationInfo()
godotPrintError(cstring($error), nil, cstring(filename), line.cint)
godotPrintError(cstring($error), cstring"", cstring(filename), line.cint)
proc print*(parts: varargs[string, `$`]) =
## Prints concatenated ``parts`` to Godot log.
@ -292,8 +293,6 @@ proc `of`*[T: NimGodotObject](obj: NimGodotObject,
## Godot-specific inheritance check.
not obj.isNil and (system.`of`(obj, T) or system.`of`(obj.linkedObject, T))
{.deprecated: [`~`: `of`].}
proc newRStrLit(s: string): NimNode {.compileTime.} =
result = newNimNode(nnkRStrLit)
result.strVal = s
@ -805,6 +804,7 @@ proc godot_nativescript_init(handle: pointer) {.
proc godot_gdnative_init(options: ptr GodotNativeInitOptions) {.
cdecl, exportc, dynlib.} =
gdNativeLibraryObj = options.gdNativeLibrary
setGDNativeAPI(options.gdNativeAPIStruct)
proc godot_gdnative_terminate(options: ptr GodotNativeTerminateOptions) {.
cdecl, exportc, dynlib.} =