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

Fix GDNative API procedure declarations

Browse source 
Earlier signature mismatch caused problems on macOS with Godot 3.1.
This commit is contained in:
Ruslan Mustakov 2018-10-11 19:06:05 +07:00
commit e9d73d8ec4
10 changed files with 342 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

2
godot.nimble
View file

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

16
godot/core/aabb.nim
View file

@ -31,10 +31,10 @@ proc encloses*(self, other: AABB): bool {.inline.} =
getGDNativeAPI().aabbEncloses(self, other) getGDNativeAPI().aabbEncloses(self, other)
proc merge*(self, other: AABB): AABB {.inline.} = proc merge*(self, other: AABB): AABB {.inline.} =
getGDNativeAPI().aabbMerge(self, other) getGDNativeAPI().aabbMerge(self, other).toAABB()
proc intersection*(self, other: AABB): AABB {.inline.} = proc intersection*(self, other: AABB): AABB {.inline.} =
getGDNativeAPI().aabbIntersection(self, other) getGDNativeAPI().aabbIntersection(self, other).toAABB()
proc intersectsPlane*(self: AABB; plane: Plane): bool {.inline.} = proc intersectsPlane*(self: AABB; plane: Plane): bool {.inline.} =
getGDNativeAPI().aabbIntersectsPlane(self, plane) getGDNativeAPI().aabbIntersectsPlane(self, plane)
@ -46,10 +46,10 @@ proc contains*(self: AABB; point: Vector3): bool {.inline.} =
getGDNativeAPI().aabbHasPoint(self, point) getGDNativeAPI().aabbHasPoint(self, point)
proc getSupport*(self: AABB; dir: Vector3): Vector3 {.inline.} = proc getSupport*(self: AABB; dir: Vector3): Vector3 {.inline.} =
getGDNativeAPI().aabbGetSupport(self, dir) getGDNativeAPI().aabbGetSupport(self, dir).toVector3()
proc getLongestAxis*(self: AABB): Vector3 {.inline.} = proc getLongestAxis*(self: AABB): Vector3 {.inline.} =
getGDNativeAPI().aabbGetLongestAxis(self) getGDNativeAPI().aabbGetLongestAxis(self).toVector3()
proc getLongestAxisIndex*(self: AABB): cint {.inline.} = proc getLongestAxisIndex*(self: AABB): cint {.inline.} =
getGDNativeAPI().aabbGetLongestAxisIndex(self) getGDNativeAPI().aabbGetLongestAxisIndex(self)
@ -58,7 +58,7 @@ proc getLongestAxisSize*(self: AABB): float32 {.inline.} =
getGDNativeAPI().aabbGetLongestAxisSize(self) getGDNativeAPI().aabbGetLongestAxisSize(self)
proc getShortestAxis*(self: AABB): Vector3 {.inline.} = proc getShortestAxis*(self: AABB): Vector3 {.inline.} =
getGDNativeAPI().aabbGetShortestAxis(self) getGDNativeAPI().aabbGetShortestAxis(self).toVector3()
proc getShortestAxisIndex*(self: AABB): cint {.inline.} = proc getShortestAxisIndex*(self: AABB): cint {.inline.} =
getGDNativeAPI().aabbGetShortestAxisIndex(self) getGDNativeAPI().aabbGetShortestAxisIndex(self)
@ -67,13 +67,13 @@ proc getShortestAxisSize*(self: AABB): float32 {.inline.} =
getGDNativeAPI().aabbGetShortestAxisSize(self) getGDNativeAPI().aabbGetShortestAxisSize(self)
proc expand*(self: AABB; toPoint: Vector3): AABB {.inline.} = proc expand*(self: AABB; toPoint: Vector3): AABB {.inline.} =
getGDNativeAPI().aabbExpand(self, toPoint) getGDNativeAPI().aabbExpand(self, toPoint).toAABB()
proc grow*(self: AABB; by: float32): AABB {.inline.} = proc grow*(self: AABB; by: float32): AABB {.inline.} =
getGDNativeAPI().aabbGrow(self, by) getGDNativeAPI().aabbGrow(self, by).toAABB()
proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} = proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} =
getGDNativeAPI().aabbGetEndpoint(self, idx) getGDNativeAPI().aabbGetEndpoint(self, idx).toVector3()
proc `==`*(a, b: AABB): bool {.inline.} = proc `==`*(a, b: AABB): bool {.inline.} =
getGDNativeAPI().aabbOperatorEqual(a, b) getGDNativeAPI().aabbOperatorEqual(a, b)

8
godot/core/colors.nim
View file

@ -64,16 +64,16 @@ proc gray*(self: Color): float32 {.inline.} =
getGDNativeAPI().colorGray(self) getGDNativeAPI().colorGray(self)
proc inverted*(self: Color): Color {.inline.} = proc inverted*(self: Color): Color {.inline.} =
getGDNativeAPI().colorInverted(self) getGDNativeAPI().colorInverted(self).toColor()
proc contrasted*(self: Color): Color {.inline.} = proc contrasted*(self: Color): Color {.inline.} =
getGDNativeAPI().colorContrasted(self) getGDNativeAPI().colorContrasted(self).toColor()
proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} = proc lerp*(self: Color; b: Color; t: float32): Color {.inline.} =
getGDNativeAPI().colorLinearInterpolate(self, b, t) getGDNativeAPI().colorLinearInterpolate(self, b, t).toColor()
proc blend*(self: Color; over: Color): Color {.inline.} = proc blend*(self: Color; over: Color): Color {.inline.} =
getGDNativeAPI().colorBlend(self, over) getGDNativeAPI().colorBlend(self, over).toColor()
proc `==`*(a, b: Color): bool {.inline.} = proc `==`*(a, b: Color): bool {.inline.} =
a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a

10
godot/core/planes.nim
View file

@ -26,13 +26,13 @@ proc hash*(self: Plane): Hash {.inline, noinit.} =
!$(self.normal.hash() !& self.d.hash()) !$(self.normal.hash() !& self.d.hash())
proc normalized*(self: Plane): Plane {.inline.} = proc normalized*(self: Plane): Plane {.inline.} =
getGDNativeAPI().planeNormalized(self) getGDNativeAPI().planeNormalized(self).toPlane()
proc center*(self: Plane): Vector3 {.inline.} = proc center*(self: Plane): Vector3 {.inline.} =
getGDNativeAPI().planeCenter(self) getGDNativeAPI().planeCenter(self).toVector3()
proc getAnyPoint*(self: Plane): Vector3 {.inline.} = proc getAnyPoint*(self: Plane): Vector3 {.inline.} =
getGDNativeAPI().planeGetAnyPoint(self) getGDNativeAPI().planeGetAnyPoint(self).toVector3()
proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} = proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} =
getGDNativeAPI().planeIsPointOver(self, point) getGDNativeAPI().planeIsPointOver(self, point)
@ -45,7 +45,7 @@ proc contains*(self: Plane; point: Vector3;
getGDNativeAPI().planeHasPoint(self, point, epsilon) getGDNativeAPI().planeHasPoint(self, point, epsilon)
proc project*(self: Plane; point: Vector3): Vector3 {.inline.} = proc project*(self: Plane; point: Vector3): Vector3 {.inline.} =
getGDNativeAPI().planeProject(self, point) getGDNativeAPI().planeProject(self, point).toVector3()
proc intersect3*(self: Plane; dest: var Vector3; proc intersect3*(self: Plane; dest: var Vector3;
b, c: Plane): bool {.inline.} = b, c: Plane): bool {.inline.} =
@ -60,7 +60,7 @@ proc intersectsSegment*(self: Plane; dest: var Vector3;
getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd) getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd)
proc `-`*(self: Plane): Plane {.inline.} = proc `-`*(self: Plane): Plane {.inline.} =
getGDNativeAPI().planeOperatorNeg(self) getGDNativeAPI().planeOperatorNeg(self).toPlane()
proc `==`*(a, b: Plane): bool {.inline.} = proc `==`*(a, b: Plane): bool {.inline.} =
getGDNativeAPI().planeOperatorEqual(a, b) getGDNativeAPI().planeOperatorEqual(a, b)

22
godot/core/quats.nim
View file

@ -29,50 +29,50 @@ proc lengthSquared*(self: Quat): float32 {.inline.} =
getGDNativeAPI().quatLengthSquared(self) getGDNativeAPI().quatLengthSquared(self)
proc normalized*(self: Quat): Quat {.inline.} = proc normalized*(self: Quat): Quat {.inline.} =
getGDNativeAPI().quatNormalized(self) getGDNativeAPI().quatNormalized(self).toQuat()
proc isNormalized*(self: Quat): bool {.inline.} = proc isNormalized*(self: Quat): bool {.inline.} =
getGDNativeAPI().quatIsNormalized(self) getGDNativeAPI().quatIsNormalized(self)
proc inverse*(self: Quat): Quat {.inline.} = proc inverse*(self: Quat): Quat {.inline.} =
getGDNativeAPI().quatInverse(self) getGDNativeAPI().quatInverse(self).toQuat()
proc dot*(a, b: Quat): float32 {.inline.} = proc dot*(a, b: Quat): float32 {.inline.} =
getGDNativeAPI().quatDot(a, b) getGDNativeAPI().quatDot(a, b)
proc xform*(self: Quat; v: Vector3): Vector3 {.inline.} = proc xform*(self: Quat; v: Vector3): Vector3 {.inline.} =
getGDNativeAPI().quatXform(self, v) getGDNativeAPI().quatXform(self, v).toVector3()
proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} = proc slerp*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
getGDNativeAPI().quatSlerp(self, b, t) getGDNativeAPI().quatSlerp(self, b, t).toQuat()
proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} = proc slerpni*(self: Quat; b: Quat; t: float32): Quat {.inline.} =
getGDNativeAPI().quatSlerpni(self, b, t) getGDNativeAPI().quatSlerpni(self, b, t).toQuat()
proc cubicSlerp*(self, b, preA, postB: Quat; proc cubicSlerp*(self, b, preA, postB: Quat;
t: float32): Quat {.inline.} = t: float32): Quat {.inline.} =
getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t) getGDNativeAPI().quatCubicSlerp(self, b, preA, postB, t).toQuat()
proc `*`*(a: Quat, b: float32): Quat {.inline.} = proc `*`*(a: Quat, b: float32): Quat {.inline.} =
getGDNativeAPI().quatOperatorMultiply(a, b) getGDNativeAPI().quatOperatorMultiply(a, b).toQuat()
proc `*=`*(a: var Quat, b: float32) {.inline.} = proc `*=`*(a: var Quat, b: float32) {.inline.} =
a = a * b a = a * b
proc `+`*(a, b: Quat): Quat {.inline.} = proc `+`*(a, b: Quat): Quat {.inline.} =
getGDNativeAPI().quatOperatorAdd(a, b) getGDNativeAPI().quatOperatorAdd(a, b).toQuat()
proc `+=`*(a: var Quat, b: Quat) {.inline.} = proc `+=`*(a: var Quat, b: Quat) {.inline.} =
a = a + b a = a + b
proc `-`*(a, b: Quat): Quat {.inline.} = proc `-`*(a, b: Quat): Quat {.inline.} =
getGDNativeAPI().quatOperatorSubtract(a, b) getGDNativeAPI().quatOperatorSubtract(a, b).toQuat()
proc `-=`* (a: var Quat, b: Quat) {.inline.} = proc `-=`* (a: var Quat, b: Quat) {.inline.} =
a = a - b a = a - b
proc `/`*(self: Quat; b: float32): Quat {.inline.} = proc `/`*(self: Quat; b: float32): Quat {.inline.} =
getGDNativeAPI().quatOperatorDivide(self, b) getGDNativeAPI().quatOperatorDivide(self, b).toQuat()
proc `/=`*(self: var Quat, b: float32) {.inline.} = proc `/=`*(self: var Quat, b: float32) {.inline.} =
self = self / b self = self / b
@ -81,4 +81,4 @@ proc `==`*(a, b: Quat): bool {.inline.} =
getGDNativeAPI().quatOperatorEqual(a, b) getGDNativeAPI().quatOperatorEqual(a, b)
proc `-`*(self: Quat): Quat {.inline.} = proc `-`*(self: Quat): Quat {.inline.} =
getGDNativeAPI().quatOperatorNeg(self) getGDNativeAPI().quatOperatorNeg(self).toQuat()

32
godot/core/transform2d.nim
View file

@ -21,59 +21,59 @@ proc hash*(self: Transform2D): Hash {.inline, noinit.} =
!$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash()) !$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash())
proc inverse*(self: Transform2D): Transform2D {.inline.} = proc inverse*(self: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DInverse(self) getGDNativeAPI().transform2DInverse(self).toTransform2D()
proc affineInverse*(self: Transform2D): Transform2D {.inline.} = proc affineInverse*(self: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DAffineInverse(self) getGDNativeAPI().transform2DAffineInverse(self).toTransform2D()
proc rotation*(self: Transform2D): float32 {.inline.} = proc rotation*(self: Transform2D): float32 {.inline.} =
getGDNativeAPI().transform2DGetRotation(self) getGDNativeAPI().transform2DGetRotation(self)
proc origin*(self: Transform2D): Vector2 {.inline.} = proc origin*(self: Transform2D): Vector2 {.inline.} =
getGDNativeAPI().transform2DGetOrigin(self) getGDNativeAPI().transform2DGetOrigin(self).toVector2()
proc scale*(self: Transform2D): Vector2 {.inline.} = proc scale*(self: Transform2D): Vector2 {.inline.} =
getGDNativeAPI().transform2DGetScale(self) getGDNativeAPI().transform2DGetScale(self).toVector2()
proc orthonormalized*(self: Transform2D): Transform2D {.inline.} = proc orthonormalized*(self: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DOrthonormalized(self) getGDNativeAPI().transform2DOrthonormalized(self).toTransform2D()
proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} = proc rotated*(self: Transform2D; phi: float32): Transform2D {.inline.} =
getGDNativeAPI().transform2DRotated(self, phi) getGDNativeAPI().transform2DRotated(self, phi).toTransform2D()
proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} = proc scaled*(self: Transform2D; scale: Vector2): Transform2D {.inline.} =
getGDNativeAPI().transform2DScaled(self, scale) getGDNativeAPI().transform2DScaled(self, scale).toTransform2D()
proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} = proc translated*(self: Transform2D; offset: Vector2): Transform2D {.inline.} =
getGDNativeAPI().transform2DTranslated(self, offset) getGDNativeAPI().transform2DTranslated(self, offset).toTransform2D()
proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = proc xformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DXformVector2(self, v) getGDNativeAPI().transform2DXformVector2(self, v).toVector2()
proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = proc xformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DXformInvVector2(self, v) getGDNativeAPI().transform2DXformInvVector2(self, v).toVector2()
proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = proc basisXformVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DBasisXformVector2(self, v) getGDNativeAPI().transform2DBasisXformVector2(self, v).toVector2()
proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} = proc basisXformInvVector2*(self: Transform2D; v: Vector2): Vector2 {.inline.} =
getGDNativeAPI().transform2DBasisXformInvVector2(self, v) getGDNativeAPI().transform2DBasisXformInvVector2(self, v).toVector2()
proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} = proc xformRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
getGDNativeAPI().transform2DXformRect2(self, rect) getGDNativeAPI().transform2DXformRect2(self, rect).toRect2()
proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} = proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
getGDNativeAPI().transform2DXformInvRect2(self, rect) getGDNativeAPI().transform2DXformInvRect2(self, rect).toRect2()
proc interpolateWith*(self, m: Transform2D; proc interpolateWith*(self, m: Transform2D;
c: float32): Transform2D {.inline.} = c: float32): Transform2D {.inline.} =
getGDNativeAPI().transform2DInterpolateWith(self, m, c) getGDNativeAPI().transform2DInterpolateWith(self, m, c).toTransform2D()
proc `==`*(a, b: Transform2D): bool {.inline.} = proc `==`*(a, b: Transform2D): bool {.inline.} =
getGDNativeAPI().transform2DOperatorEqual(a, b) getGDNativeAPI().transform2DOperatorEqual(a, b)
proc `*`*(a, b: Transform2D): Transform2D {.inline.} = proc `*`*(a, b: Transform2D): Transform2D {.inline.} =
getGDNativeAPI().transform2DOperatorMultiply(a, b) getGDNativeAPI().transform2DOperatorMultiply(a, b).toTransform2D()
proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} = proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} =
a = a * b a = a * b

28
godot/core/transforms.nim
View file

@ -27,50 +27,50 @@ proc hash*(self: Transform): Hash {.inline.} =
!$(self.basis.hash() !& self.origin.hash()) !$(self.basis.hash() !& self.origin.hash())
proc inverse*(self: Transform): Transform {.inline.} = proc inverse*(self: Transform): Transform {.inline.} =
getGDNativeAPI().transformInverse(self) getGDNativeAPI().transformInverse(self).toTransform()
proc affineInverse*(self: Transform): Transform {.inline.} = proc affineInverse*(self: Transform): Transform {.inline.} =
getGDNativeAPI().transformAffineInverse(self) getGDNativeAPI().transformAffineInverse(self).toTransform()
proc orthonormalized*(self: Transform): Transform {.inline.} = proc orthonormalized*(self: Transform): Transform {.inline.} =
getGDNativeAPI().transformOrthonormalized(self) getGDNativeAPI().transformOrthonormalized(self).toTransform()
proc rotated*(self: Transform; axis: Vector3; proc rotated*(self: Transform; axis: Vector3;
phi: float32): Transform {.inline.} = phi: float32): Transform {.inline.} =
getGDNativeAPI().transformRotated(self, axis, phi) getGDNativeAPI().transformRotated(self, axis, phi).toTransform()
proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} = proc scaled*(self: Transform; scale: Vector3): Transform {.inline.} =
getGDNativeAPI().transformScaled(self, scale) getGDNativeAPI().transformScaled(self, scale).toTransform()
proc translated*(self: Transform; offset: Vector3): Transform {.inline.} = proc translated*(self: Transform; offset: Vector3): Transform {.inline.} =
getGDNativeAPI().transformTranslated(self, offset) getGDNativeAPI().transformTranslated(self, offset).toTransform()
proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} = proc lookingAt*(self: Transform; target, up: Vector3): Transform {.inline.} =
getGDNativeAPI().transformLookingAt(self, target, up) getGDNativeAPI().transformLookingAt(self, target, up).toTransform()
proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} = proc xformPlane*(self: Transform; plane: Plane): Plane {.inline.} =
getGDNativeAPI().transformXformPlane(self, plane) getGDNativeAPI().transformXformPlane(self, plane).toPlane()
proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} = proc xformInvPlane*(self: Transform; plane: Plane): Plane {.inline.} =
getGDNativeAPI().transformXformInvPlane(self, plane) getGDNativeAPI().transformXformInvPlane(self, plane).toPlane()
proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = proc xformVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
getGDNativeAPI().transformXformVector3(self, v) getGDNativeAPI().transformXformVector3(self, v).toVector3()
proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} = proc xformInvVector3*(self: Transform; v: Vector3): Vector3 {.inline.} =
getGDNativeAPI().transformXformInvVector3(self, v) getGDNativeAPI().transformXformInvVector3(self, v).toVector3()
proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} = proc xformAABB*(self: Transform; rect: AABB): AABB {.inline.} =
getGDNativeAPI().transformXformAABB(self, rect) getGDNativeAPI().transformXformAABB(self, rect).toAABB()
proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} = proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} =
getGDNativeAPI().transformXformInvAABB(self, rect) getGDNativeAPI().transformXformInvAABB(self, rect).toAABB()
proc `==`*(self: Transform; b: Transform): bool {.inline.} = proc `==`*(self: Transform; b: Transform): bool {.inline.} =
getGDNativeAPI().transformOperatorEqual(self, b) getGDNativeAPI().transformOperatorEqual(self, b)
proc `*`*(self, other: Transform): Transform {.inline.} = proc `*`*(self, other: Transform): Transform {.inline.} =
getGDNativeAPI().transformOperatorMultiply(self, other) getGDNativeAPI().transformOperatorMultiply(self, other).toTransform()
proc `*=`*(self: var Transform, other: Transform) {.inline.} = proc `*=`*(self: var Transform, other: Transform) {.inline.} =
self = self * other self = self * other

466
godot/gdnativeapi.nim
View file

File diff suppressed because it is too large Load diff

10
godot/internal/godotpoolarrays.nim
View file

@ -45,7 +45,15 @@ template genPoolArrayAPI(ArrayT, initIdent, DataT,
getGDNativeAPI().setProc(self, idx, data) getGDNativeAPI().setProc(self, idx, data)
proc `[]`*(self: ArrayT; idx: cint): DataT {.inline.} = proc `[]`*(self: ArrayT; idx: cint): DataT {.inline.} =
getGDNativeAPI().getProc(self, idx) let data = getGDNativeAPI().getProc(self, idx)
when DataT is Color:
data.toColor()
elif DataT is Vector2:
data.toVector2()
elif DataT is Vector3:
data.toVector3()
else:
data
proc len*(self: ArrayT): cint {.inline.} = proc len*(self: ArrayT): cint {.inline.} =
getGDNativeAPI().sizeProc(self) getGDNativeAPI().sizeProc(self)

20
godot/internal/godotvariants.nim
View file

@ -121,34 +121,34 @@ proc asGodotString*(self: GodotVariant): GodotString {.inline.} =
getGDNativeAPI().variantAsString(self) getGDNativeAPI().variantAsString(self)
proc asVector2*(self: GodotVariant): Vector2 {.inline.} = proc asVector2*(self: GodotVariant): Vector2 {.inline.} =
getGDNativeAPI().variantAsVector2(self) getGDNativeAPI().variantAsVector2(self).toVector2()
proc asRect2*(self: GodotVariant): Rect2 {.inline.} = proc asRect2*(self: GodotVariant): Rect2 {.inline.} =
getGDNativeAPI().variantAsRect2(self) getGDNativeAPI().variantAsRect2(self).toRect2()
proc asVector3*(self: GodotVariant): Vector3 {.inline.} = proc asVector3*(self: GodotVariant): Vector3 {.inline.} =
getGDNativeAPI().variantAsVector3(self) getGDNativeAPI().variantAsVector3(self).toVector3()
proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} = proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} =
getGDNativeAPI().variantAsTransform2D(self) getGDNativeAPI().variantAsTransform2D(self).toTransform2D()
proc asPlane*(self: GodotVariant): Plane {.inline.} = proc asPlane*(self: GodotVariant): Plane {.inline.} =
getGDNativeAPI().variantAsPlane(self) getGDNativeAPI().variantAsPlane(self).toPlane()
proc asQuat*(self: GodotVariant): Quat {.inline.} = proc asQuat*(self: GodotVariant): Quat {.inline.} =
getGDNativeAPI().variantAsQuat(self) getGDNativeAPI().variantAsQuat(self).toQuat()
proc asAABB*(self: GodotVariant): AABB {.inline.} = proc asAABB*(self: GodotVariant): AABB {.inline.} =
getGDNativeAPI().variantAsAABB(self) getGDNativeAPI().variantAsAABB(self).toAABB()
proc asBasis*(self: GodotVariant): Basis {.inline.} = proc asBasis*(self: GodotVariant): Basis {.inline.} =
getGDNativeAPI().variantAsBasis(self) getGDNativeAPI().variantAsBasis(self).toBasis()
proc asTransform*(self: GodotVariant): Transform {.inline.} = proc asTransform*(self: GodotVariant): Transform {.inline.} =
getGDNativeAPI().variantAsTransform(self) getGDNativeAPI().variantAsTransform(self).toTransform()
proc asColor*(self: GodotVariant): Color {.inline.} = proc asColor*(self: GodotVariant): Color {.inline.} =
getGDNativeAPI().variantAsColor(self) getGDNativeAPI().variantAsColor(self).toColor()
proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} = proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} =
getGDNativeAPI().variantAsNodePath(self) getGDNativeAPI().variantAsNodePath(self)