Fix GDNative API procedure declarations
Earlier signature mismatch caused problems on macOS with Godot 3.1.
This commit is contained in:
Ruslan Mustakov
parent
859f9f04fb
commit
e9d73d8ec4
10 changed files with 342 additions and 272 deletions
|
|
@ -1,4 +1,4 @@
|
|||
version = "0.7.17"
|
||||
version = "0.7.18"
|
||||
author = "Xored Software, Inc."
|
||||
description = "Godot Engine bindings"
|
||||
license = "MIT"
|
||||
|
|
|
|||
|
|
@ -31,10 +31,10 @@ proc encloses*(self, other: AABB): bool {.inline.} =
|
|||
getGDNativeAPI().aabbEncloses(self, other)
|
||||
|
||||
proc merge*(self, other: AABB): AABB {.inline.} =
|
||||
getGDNativeAPI().aabbMerge(self, other)
|
||||
getGDNativeAPI().aabbMerge(self, other).toAABB()
|
||||
|
||||
proc intersection*(self, other: AABB): AABB {.inline.} =
|
||||
getGDNativeAPI().aabbIntersection(self, other)
|
||||
getGDNativeAPI().aabbIntersection(self, other).toAABB()
|
||||
|
||||
proc intersectsPlane*(self: AABB; plane: Plane): bool {.inline.} =
|
||||
getGDNativeAPI().aabbIntersectsPlane(self, plane)
|
||||
|
|
@ -46,10 +46,10 @@ proc contains*(self: AABB; point: Vector3): bool {.inline.} =
|
|||
getGDNativeAPI().aabbHasPoint(self, point)
|
||||
|
||||
proc getSupport*(self: AABB; dir: Vector3): Vector3 {.inline.} =
|
||||
getGDNativeAPI().aabbGetSupport(self, dir)
|
||||
getGDNativeAPI().aabbGetSupport(self, dir).toVector3()
|
||||
|
||||
proc getLongestAxis*(self: AABB): Vector3 {.inline.} =
|
||||
getGDNativeAPI().aabbGetLongestAxis(self)
|
||||
getGDNativeAPI().aabbGetLongestAxis(self).toVector3()
|
||||
|
||||
proc getLongestAxisIndex*(self: AABB): cint {.inline.} =
|
||||
getGDNativeAPI().aabbGetLongestAxisIndex(self)
|
||||
|
|
@ -58,7 +58,7 @@ proc getLongestAxisSize*(self: AABB): float32 {.inline.} =
|
|||
getGDNativeAPI().aabbGetLongestAxisSize(self)
|
||||
|
||||
proc getShortestAxis*(self: AABB): Vector3 {.inline.} =
|
||||
getGDNativeAPI().aabbGetShortestAxis(self)
|
||||
getGDNativeAPI().aabbGetShortestAxis(self).toVector3()
|
||||
|
||||
proc getShortestAxisIndex*(self: AABB): cint {.inline.} =
|
||||
getGDNativeAPI().aabbGetShortestAxisIndex(self)
|
||||
|
|
@ -67,13 +67,13 @@ proc getShortestAxisSize*(self: AABB): float32 {.inline.} =
|
|||
getGDNativeAPI().aabbGetShortestAxisSize(self)
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().aabbGrow(self, by)
|
||||
getGDNativeAPI().aabbGrow(self, by).toAABB()
|
||||
|
||||
proc getEndpoint*(self: AABB; idx: cint): Vector3 {.inline.} =
|
||||
getGDNativeAPI().aabbGetEndpoint(self, idx)
|
||||
getGDNativeAPI().aabbGetEndpoint(self, idx).toVector3()
|
||||
|
||||
proc `==`*(a, b: AABB): bool {.inline.} =
|
||||
getGDNativeAPI().aabbOperatorEqual(a, b)
|
||||
|
|
|
|||
|
|
@ -64,16 +64,16 @@ proc gray*(self: Color): float32 {.inline.} =
|
|||
getGDNativeAPI().colorGray(self)
|
||||
|
||||
proc inverted*(self: Color): Color {.inline.} =
|
||||
getGDNativeAPI().colorInverted(self)
|
||||
getGDNativeAPI().colorInverted(self).toColor()
|
||||
|
||||
proc contrasted*(self: Color): Color {.inline.} =
|
||||
getGDNativeAPI().colorContrasted(self)
|
||||
getGDNativeAPI().colorContrasted(self).toColor()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().colorBlend(self, over)
|
||||
getGDNativeAPI().colorBlend(self, over).toColor()
|
||||
|
||||
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
|
||||
|
|
|
|||
|
|
@ -26,13 +26,13 @@ proc hash*(self: Plane): Hash {.inline, noinit.} =
|
|||
!$(self.normal.hash() !& self.d.hash())
|
||||
|
||||
proc normalized*(self: Plane): Plane {.inline.} =
|
||||
getGDNativeAPI().planeNormalized(self)
|
||||
getGDNativeAPI().planeNormalized(self).toPlane()
|
||||
|
||||
proc center*(self: Plane): Vector3 {.inline.} =
|
||||
getGDNativeAPI().planeCenter(self)
|
||||
getGDNativeAPI().planeCenter(self).toVector3()
|
||||
|
||||
proc getAnyPoint*(self: Plane): Vector3 {.inline.} =
|
||||
getGDNativeAPI().planeGetAnyPoint(self)
|
||||
getGDNativeAPI().planeGetAnyPoint(self).toVector3()
|
||||
|
||||
proc isPointOver*(self: Plane; point: Vector3): bool {.inline.} =
|
||||
getGDNativeAPI().planeIsPointOver(self, point)
|
||||
|
|
@ -45,7 +45,7 @@ proc contains*(self: Plane; point: Vector3;
|
|||
getGDNativeAPI().planeHasPoint(self, point, epsilon)
|
||||
|
||||
proc project*(self: Plane; point: Vector3): Vector3 {.inline.} =
|
||||
getGDNativeAPI().planeProject(self, point)
|
||||
getGDNativeAPI().planeProject(self, point).toVector3()
|
||||
|
||||
proc intersect3*(self: Plane; dest: var Vector3;
|
||||
b, c: Plane): bool {.inline.} =
|
||||
|
|
@ -60,7 +60,7 @@ proc intersectsSegment*(self: Plane; dest: var Vector3;
|
|||
getGDNativeAPI().planeIntersectsSegment(self, dest, segmentBegin, segmentEnd)
|
||||
|
||||
proc `-`*(self: Plane): Plane {.inline.} =
|
||||
getGDNativeAPI().planeOperatorNeg(self)
|
||||
getGDNativeAPI().planeOperatorNeg(self).toPlane()
|
||||
|
||||
proc `==`*(a, b: Plane): bool {.inline.} =
|
||||
getGDNativeAPI().planeOperatorEqual(a, b)
|
||||
|
|
|
|||
|
|
@ -29,50 +29,50 @@ proc lengthSquared*(self: Quat): float32 {.inline.} =
|
|||
getGDNativeAPI().quatLengthSquared(self)
|
||||
|
||||
proc normalized*(self: Quat): Quat {.inline.} =
|
||||
getGDNativeAPI().quatNormalized(self)
|
||||
getGDNativeAPI().quatNormalized(self).toQuat()
|
||||
|
||||
proc isNormalized*(self: Quat): bool {.inline.} =
|
||||
getGDNativeAPI().quatIsNormalized(self)
|
||||
|
||||
proc inverse*(self: Quat): Quat {.inline.} =
|
||||
getGDNativeAPI().quatInverse(self)
|
||||
getGDNativeAPI().quatInverse(self).toQuat()
|
||||
|
||||
proc dot*(a, b: Quat): float32 {.inline.} =
|
||||
getGDNativeAPI().quatDot(a, b)
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().quatSlerp(self, b, t)
|
||||
getGDNativeAPI().quatSlerp(self, b, t).toQuat()
|
||||
|
||||
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;
|
||||
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.} =
|
||||
getGDNativeAPI().quatOperatorMultiply(a, b)
|
||||
getGDNativeAPI().quatOperatorMultiply(a, b).toQuat()
|
||||
|
||||
proc `*=`*(a: var Quat, b: float32) {.inline.} =
|
||||
a = a * b
|
||||
|
||||
proc `+`*(a, b: Quat): Quat {.inline.} =
|
||||
getGDNativeAPI().quatOperatorAdd(a, b)
|
||||
getGDNativeAPI().quatOperatorAdd(a, b).toQuat()
|
||||
|
||||
proc `+=`*(a: var Quat, b: Quat) {.inline.} =
|
||||
a = a + b
|
||||
|
||||
proc `-`*(a, b: Quat): Quat {.inline.} =
|
||||
getGDNativeAPI().quatOperatorSubtract(a, b)
|
||||
getGDNativeAPI().quatOperatorSubtract(a, b).toQuat()
|
||||
|
||||
proc `-=`* (a: var Quat, b: Quat) {.inline.} =
|
||||
a = a - b
|
||||
|
||||
proc `/`*(self: Quat; b: float32): Quat {.inline.} =
|
||||
getGDNativeAPI().quatOperatorDivide(self, b)
|
||||
getGDNativeAPI().quatOperatorDivide(self, b).toQuat()
|
||||
|
||||
proc `/=`*(self: var Quat, b: float32) {.inline.} =
|
||||
self = self / b
|
||||
|
|
@ -81,4 +81,4 @@ proc `==`*(a, b: Quat): bool {.inline.} =
|
|||
getGDNativeAPI().quatOperatorEqual(a, b)
|
||||
|
||||
proc `-`*(self: Quat): Quat {.inline.} =
|
||||
getGDNativeAPI().quatOperatorNeg(self)
|
||||
getGDNativeAPI().quatOperatorNeg(self).toQuat()
|
||||
|
|
|
|||
|
|
@ -21,59 +21,59 @@ proc hash*(self: Transform2D): Hash {.inline, noinit.} =
|
|||
!$(self.elements[0].hash() !& self.elements[1].hash() !& self.elements[2].hash())
|
||||
|
||||
proc inverse*(self: Transform2D): Transform2D {.inline.} =
|
||||
getGDNativeAPI().transform2DInverse(self)
|
||||
getGDNativeAPI().transform2DInverse(self).toTransform2D()
|
||||
|
||||
proc affineInverse*(self: Transform2D): Transform2D {.inline.} =
|
||||
getGDNativeAPI().transform2DAffineInverse(self)
|
||||
getGDNativeAPI().transform2DAffineInverse(self).toTransform2D()
|
||||
|
||||
proc rotation*(self: Transform2D): float32 {.inline.} =
|
||||
getGDNativeAPI().transform2DGetRotation(self)
|
||||
|
||||
proc origin*(self: Transform2D): Vector2 {.inline.} =
|
||||
getGDNativeAPI().transform2DGetOrigin(self)
|
||||
getGDNativeAPI().transform2DGetOrigin(self).toVector2()
|
||||
|
||||
proc scale*(self: Transform2D): Vector2 {.inline.} =
|
||||
getGDNativeAPI().transform2DGetScale(self)
|
||||
getGDNativeAPI().transform2DGetScale(self).toVector2()
|
||||
|
||||
proc orthonormalized*(self: Transform2D): Transform2D {.inline.} =
|
||||
getGDNativeAPI().transform2DOrthonormalized(self)
|
||||
getGDNativeAPI().transform2DOrthonormalized(self).toTransform2D()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transform2DScaled(self, scale)
|
||||
getGDNativeAPI().transform2DScaled(self, scale).toTransform2D()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transform2DXformVector2(self, v)
|
||||
getGDNativeAPI().transform2DXformVector2(self, v).toVector2()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transform2DBasisXformVector2(self, v)
|
||||
getGDNativeAPI().transform2DBasisXformVector2(self, v).toVector2()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transform2DXformRect2(self, rect)
|
||||
getGDNativeAPI().transform2DXformRect2(self, rect).toRect2()
|
||||
|
||||
proc xformInvRect2*(self: Transform2D; rect: Rect2): Rect2 {.inline.} =
|
||||
getGDNativeAPI().transform2DXformInvRect2(self, rect)
|
||||
getGDNativeAPI().transform2DXformInvRect2(self, rect).toRect2()
|
||||
|
||||
proc interpolateWith*(self, m: Transform2D;
|
||||
c: float32): Transform2D {.inline.} =
|
||||
getGDNativeAPI().transform2DInterpolateWith(self, m, c)
|
||||
getGDNativeAPI().transform2DInterpolateWith(self, m, c).toTransform2D()
|
||||
|
||||
proc `==`*(a, b: Transform2D): bool {.inline.} =
|
||||
getGDNativeAPI().transform2DOperatorEqual(a, b)
|
||||
|
||||
proc `*`*(a, b: Transform2D): Transform2D {.inline.} =
|
||||
getGDNativeAPI().transform2DOperatorMultiply(a, b)
|
||||
getGDNativeAPI().transform2DOperatorMultiply(a, b).toTransform2D()
|
||||
|
||||
proc `*=`*(a: var Transform2D, b: Transform2D) {.inline.} =
|
||||
a = a * b
|
||||
|
|
|
|||
|
|
@ -27,50 +27,50 @@ proc hash*(self: Transform): Hash {.inline.} =
|
|||
!$(self.basis.hash() !& self.origin.hash())
|
||||
|
||||
proc inverse*(self: Transform): Transform {.inline.} =
|
||||
getGDNativeAPI().transformInverse(self)
|
||||
getGDNativeAPI().transformInverse(self).toTransform()
|
||||
|
||||
proc affineInverse*(self: Transform): Transform {.inline.} =
|
||||
getGDNativeAPI().transformAffineInverse(self)
|
||||
getGDNativeAPI().transformAffineInverse(self).toTransform()
|
||||
|
||||
proc orthonormalized*(self: Transform): Transform {.inline.} =
|
||||
getGDNativeAPI().transformOrthonormalized(self)
|
||||
getGDNativeAPI().transformOrthonormalized(self).toTransform()
|
||||
|
||||
proc rotated*(self: Transform; axis: Vector3;
|
||||
phi: float32): Transform {.inline.} =
|
||||
getGDNativeAPI().transformRotated(self, axis, phi)
|
||||
getGDNativeAPI().transformRotated(self, axis, phi).toTransform()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transformTranslated(self, offset)
|
||||
getGDNativeAPI().transformTranslated(self, offset).toTransform()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transformXformPlane(self, plane)
|
||||
getGDNativeAPI().transformXformPlane(self, plane).toPlane()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transformXformVector3(self, v)
|
||||
getGDNativeAPI().transformXformVector3(self, v).toVector3()
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().transformXformAABB(self, rect)
|
||||
getGDNativeAPI().transformXformAABB(self, rect).toAABB()
|
||||
|
||||
proc xformInvAABB*(self: Transform; rect: AABB): AABB {.inline.} =
|
||||
getGDNativeAPI().transformXformInvAABB(self, rect)
|
||||
getGDNativeAPI().transformXformInvAABB(self, rect).toAABB()
|
||||
|
||||
proc `==`*(self: Transform; b: Transform): bool {.inline.} =
|
||||
getGDNativeAPI().transformOperatorEqual(self, b)
|
||||
|
||||
proc `*`*(self, other: Transform): Transform {.inline.} =
|
||||
getGDNativeAPI().transformOperatorMultiply(self, other)
|
||||
getGDNativeAPI().transformOperatorMultiply(self, other).toTransform()
|
||||
|
||||
proc `*=`*(self: var Transform, other: Transform) {.inline.} =
|
||||
self = self * other
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -45,7 +45,15 @@ template genPoolArrayAPI(ArrayT, initIdent, DataT,
|
|||
getGDNativeAPI().setProc(self, idx, data)
|
||||
|
||||
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.} =
|
||||
getGDNativeAPI().sizeProc(self)
|
||||
|
|
|
|||
|
|
@ -121,34 +121,34 @@ proc asGodotString*(self: GodotVariant): GodotString {.inline.} =
|
|||
getGDNativeAPI().variantAsString(self)
|
||||
|
||||
proc asVector2*(self: GodotVariant): Vector2 {.inline.} =
|
||||
getGDNativeAPI().variantAsVector2(self)
|
||||
getGDNativeAPI().variantAsVector2(self).toVector2()
|
||||
|
||||
proc asRect2*(self: GodotVariant): Rect2 {.inline.} =
|
||||
getGDNativeAPI().variantAsRect2(self)
|
||||
getGDNativeAPI().variantAsRect2(self).toRect2()
|
||||
|
||||
proc asVector3*(self: GodotVariant): Vector3 {.inline.} =
|
||||
getGDNativeAPI().variantAsVector3(self)
|
||||
getGDNativeAPI().variantAsVector3(self).toVector3()
|
||||
|
||||
proc asTransform2D*(self: GodotVariant): Transform2D {.inline.} =
|
||||
getGDNativeAPI().variantAsTransform2D(self)
|
||||
getGDNativeAPI().variantAsTransform2D(self).toTransform2D()
|
||||
|
||||
proc asPlane*(self: GodotVariant): Plane {.inline.} =
|
||||
getGDNativeAPI().variantAsPlane(self)
|
||||
getGDNativeAPI().variantAsPlane(self).toPlane()
|
||||
|
||||
proc asQuat*(self: GodotVariant): Quat {.inline.} =
|
||||
getGDNativeAPI().variantAsQuat(self)
|
||||
getGDNativeAPI().variantAsQuat(self).toQuat()
|
||||
|
||||
proc asAABB*(self: GodotVariant): AABB {.inline.} =
|
||||
getGDNativeAPI().variantAsAABB(self)
|
||||
getGDNativeAPI().variantAsAABB(self).toAABB()
|
||||
|
||||
proc asBasis*(self: GodotVariant): Basis {.inline.} =
|
||||
getGDNativeAPI().variantAsBasis(self)
|
||||
getGDNativeAPI().variantAsBasis(self).toBasis()
|
||||
|
||||
proc asTransform*(self: GodotVariant): Transform {.inline.} =
|
||||
getGDNativeAPI().variantAsTransform(self)
|
||||
getGDNativeAPI().variantAsTransform(self).toTransform()
|
||||
|
||||
proc asColor*(self: GodotVariant): Color {.inline.} =
|
||||
getGDNativeAPI().variantAsColor(self)
|
||||
getGDNativeAPI().variantAsColor(self).toColor()
|
||||
|
||||
proc asNodePath*(self: GodotVariant): GodotNodePath {.inline.} =
|
||||
getGDNativeAPI().variantAsNodePath(self)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue