diff --git a/index.html b/index.html index e0847c0..bda417b 100644 --- a/index.html +++ b/index.html @@ -2,6 +2,6 @@ godot-nim docs index

Documentation of Nim bindings for Godot Engine (GitHub)


-master
v0.5.0
v0.5.1
v0.5.2
v0.5.3
v0.5.4
v0.5.5
v0.7.2
+master
v0.5.0
v0.5.1
v0.5.2
v0.5.3
v0.5.4
v0.5.5
v0.7.2
v0.7.4
diff --git a/v0.7.4/aabb.html b/v0.7.4/aabb.html new file mode 100644 index 0000000..2e898f8 --- /dev/null +++ b/v0.7.4/aabb.html @@ -0,0 +1,1533 @@ + + + + + + + + + + + + + + + + + +Module aabb + + + + + + + + +
+
+

Module aabb

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initAABB(pos, size: Vector3): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: AABB): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc area(self: AABB): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hasNoArea(self: AABB): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hasNoSurface(self: AABB): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersects(self, other: AABB): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc encloses(self, other: AABB): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc merge(self, other: AABB): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersection(self, other: AABB): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersectsPlane(self: AABB; plane: Plane): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersectsSegment(self: AABB; start, to: Vector3): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: AABB; point: Vector3): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getSupport(self: AABB; dir: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getLongestAxis(self: AABB): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getLongestAxisIndex(self: AABB): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getLongestAxisSize(self: AABB): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getShortestAxis(self: AABB): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getShortestAxisIndex(self: AABB): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getShortestAxisSize(self: AABB): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc expand(self: AABB; toPoint: Vector3): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc grow(self: AABB; by: float32): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getEndpoint(self: AABB; idx: cint): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: AABB): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:37 UTC +
+
+
+
+ + + diff --git a/v0.7.4/arrays.html b/v0.7.4/arrays.html new file mode 100644 index 0000000..fac6e85 --- /dev/null +++ b/v0.7.4/arrays.html @@ -0,0 +1,1733 @@ + + + + + + + + + + + + + + + + + +Module arrays + + + + + + + + +
+
+

Module arrays

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Types

+
+
Array = ref object
+  godotArray: GodotArray
+
+
+ +  Source +Edit + +
+ +
+
+

Procs

+
+
proc godotArray(arr: Array): ptr GodotArray {.
inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of arr +  Source +Edit + +
+
proc newArray(arr: GodotArray): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(s: varargs[Variant]): Array {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(s: openArray[Variant]): Array {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(pca: PoolColorArray): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(pv3a: PoolVector3Array): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(pv2a: PoolVector2Array): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(psa: PoolStringArray): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(pra: PoolRealArray): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(pia: PoolIntArray): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newArray(pba: PoolByteArray): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: Array; idx: int; value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: Array; idx: int): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self: Array; value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc clear(self: Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc count(self: Array; value: Variant): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEmpty(self: Array): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc erase(self: Array; value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc first(self: Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc last(self: Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc find(self: Array; what: Variant; f: int): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc findLast(self: Array; what: Variant): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: Array; value: Variant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hash(self: Array): Hash {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self: Array; pos: int; value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self: Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc popLast(self: Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc popFirst(self: Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc addLast(self: Array; value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc addFirst(self: Array; value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self: Array; idx: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self: Array; size: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rfind(self: Array; what: Variant; fromIdx: int): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self: Array): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc sort(self: Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Array): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Iterators

+
+
iterator items(self: Array): Variant {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(self: Array): tuple[key: int, val: Variant] {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:38 UTC +
+
+
+
+ + + diff --git a/v0.7.4/basis.html b/v0.7.4/basis.html new file mode 100644 index 0000000..49fc922 --- /dev/null +++ b/v0.7.4/basis.html @@ -0,0 +1,1945 @@ + + + + + + + + + + + + + + + + + +Module basis + + + + + + + + +
+
+

Module basis

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc setCells(basis: var Basis; xx, xy, xz, yx, yy, yz, zx, zy, zz: float32) {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: Basis; row: range[0 .. 2]): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: var Basis; row: range[0 .. 2]): var Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: var Basis; row: range[0 .. 2]; value: Vector3) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self, other: Basis): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEqualApprox(self, other: Basis): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc tdotx(self: Basis; v: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc tdoty(self: Basis; v: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc tdotz(self: Basis; v: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+`(self, other: Basis): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+=`(self: var Basis; other: Basis) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(self, other: Basis): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-=`(self: var Basis; other: Basis) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(self, other: Basis): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(self: var Basis; other: Basis) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(self: var Basis; b: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(self: Basis; b: float32): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initBasis(): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initBasis(row0, row1, row2: Vector3): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initBasis(xx, xy, xz, yx, yy, yz, zx, zy, zz: float32): Basis {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initBasis(euler: Quat): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initBasis(axis: Vector3; phi: float32): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setEuler(self: var Basis; euler: Vector3) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getEuler(self: Basis): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initBasis(euler: Vector3): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc outer(self, other: Vector3): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc toDiagonalMatrix(self: Vector3): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Basis): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc invert(self: var Basis) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc inverse(self: Basis): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc axis(self: Basis; idx: range[0 .. 2]): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setAxis(self: var Basis; idx: range[0 .. 2]; value: Vector3) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc row(self: Basis; row: range[0 .. 2]): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setRow(self: var Basis; row: range[0 .. 2]; value: Vector3) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc getMainDiagonal(self: Basis): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc zero(self: var Basis) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc orthonormalized(self: Basis): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc transpose(self: var Basis) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc transposed(self: Basis): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isOrthogonal(self: Basis): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isRotation(self: Basis): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isSymmetric(self: Basis): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc scale(self: var Basis; scale: Vector3) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc scaled(self: Basis; scale: Vector3): Basis {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotated(self: Basis; axis: Vector3; phi: float32): Basis {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc rotate(self: var Basis; axis: Vector3; phi: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotated(self: Basis; euler: Vector3): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotate(self: var Basis; euler: Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getScale(self: Basis): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getRotation(self: Basis): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setScale(self: var Basis; scale: Vector3) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setRotationEuler(self: var Basis; euler: Vector3) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setRotationAxisAngle(self: var Basis; axis: Vector3; angle: float32) {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc asQuat(self: Basis): Quat {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xform(self: Basis; v: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformInv(self: Basis; v: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc orthogonalIndex(self: Basis): int {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setOrthogonalIndex(self: var Basis; idx: range[0 .. 23]) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotate(self: var Vector3; axis: Vector3; phi: float32) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotated(self: Vector3; axis: Vector3; phi: float32): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:38 UTC +
+
+
+
+ + + diff --git a/v0.7.4/colors.html b/v0.7.4/colors.html new file mode 100644 index 0000000..7e6f799 --- /dev/null +++ b/v0.7.4/colors.html @@ -0,0 +1,1444 @@ + + + + + + + + + + + + + + + + + +Module colors + + + + + + + + +
+
+

Module colors

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initColor(r, g, b: float32; a: float32 = 1.0'f32): Color {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initColor(): Color {.
inline, raises: [], tags: []
.}
+
+Initializes black color with 1.0 alpha +  Source +Edit + +
+
proc h(self: Color): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc s(self: Color): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc v(self: Color): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Color): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc toHtml(self: Color; withAlpha: bool): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc toARGB32(self: Color): uint32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc gray(self: Color): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc inverted(self: Color): Color {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contrasted(self: Color): Color {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc lerp(self: Color; b: Color; t: float32): Color {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc blend(self: Color; over: Color): Color {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: Color): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(a, b: Color): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:39 UTC +
+
+
+
+ + + diff --git a/v0.7.4/dictionaries.html b/v0.7.4/dictionaries.html new file mode 100644 index 0000000..187e883 --- /dev/null +++ b/v0.7.4/dictionaries.html @@ -0,0 +1,1568 @@ + + + + + + + + + + + + + + + + + +Module dictionaries + + + + + + + + +
+
+

Module dictionaries

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Types

+
+
Dictionary = ref object
+  godotDictionary: GodotDictionary
+
+
+ +  Source +Edit + +
+ +
+
+

Procs

+
+
proc newDictionary(): Dictionary {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newDictionary(dict: GodotDictionary): Dictionary {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotDictionary(dict: Dictionary): ptr GodotDictionary {.
raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of dict +  Source +Edit + +
+
proc len(self: Dictionary): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEmpty(self: Dictionary): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc clear(self: Dictionary) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(dict: Dictionary): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asDictionary(self: Variant): Dictionary {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: Dictionary; key: Variant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: Dictionary; keys: Array): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc del(self: Dictionary; key: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hash(self: Dictionary): Hash {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc keys(self: Dictionary): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc values(self: Dictionary): Array {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: Dictionary; key: Variant): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: Dictionary; keyStr: string): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: Dictionary; key, value: Variant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self, other: Dictionary): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc toJson(self: Dictionary): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Dictionary): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Iterators

+
+
iterator keys(dict: Dictionary): Variant {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator values(dict: Dictionary): Variant {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(dict: Dictionary): tuple[key, val: Variant] {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:39 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godot.html b/v0.7.4/godot.html new file mode 100644 index 0000000..96788cb --- /dev/null +++ b/v0.7.4/godot.html @@ -0,0 +1,1268 @@ + + + + + + + + + + + + + + + + + +Module godot + + + + + + + + +
+
+

Module godot

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ + +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:37 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotapigen.html b/v0.7.4/godotapigen.html new file mode 100644 index 0000000..9abd4bc --- /dev/null +++ b/v0.7.4/godotapigen.html @@ -0,0 +1,1292 @@ + + + + + + + + + + + + + + + + + +Module godotapigen + + + + + + + + +
+
+

Module godotapigen

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc genApi(targetDir: string; apiJsonFile: string) {.
raises: [Exception, ValueError,
+    JsonParsingError, KeyError, AssertionError, IOError],
+    tags: [ReadIOEffect, WriteIOEffect, RootEffect]
.}
+
+Generates .nim files in the targetDir based on the apiJsonFile. The JSON file can be generated by executing Godot with --gdnative-generate-json-api <target_filename> parameters. +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:35 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotarrays.html b/v0.7.4/godotarrays.html new file mode 100644 index 0000000..6c90f6e --- /dev/null +++ b/v0.7.4/godotarrays.html @@ -0,0 +1,1792 @@ + + + + + + + + + + + + + + + + + +Module godotarrays + + + + + + + + +
+
+

Module godotarrays

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc len(self: GodotArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; pca: GodotPoolColorArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; pv3a: GodotPoolVector3Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; pv2a: GodotPoolVector2Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; psa: GodotPoolStringArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; pra: GodotPoolRealArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; pia: GodotPoolIntArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; pba: GodotPoolByteArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotArray(dest: var GodotArray; src: GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self: var GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: var GodotArray; idx: cint; value: GodotVariant) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: GodotArray; idx: cint): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc mget(self: var GodotArray; idx: cint): ptr GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self: var GodotArray; value: GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc clear(self: var GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc count(self: GodotArray; value: GodotVariant): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEmpty(self: GodotArray): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc erase(self: var GodotArray; value: GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc first(self: GodotArray): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc last(self: GodotArray): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc find(self: GodotArray; what: GodotVariant; fromIdx: cint): cint {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc findLast(self: GodotArray; what: GodotVariant): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: GodotArray; value: GodotVariant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotHash(self: GodotArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hash(self: GodotArray): Hash {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self: var GodotArray; pos: cint; value: GodotVariant): Error {.
discardable,
+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self: var GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc popLast(self: var GodotArray): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc popFirst(self: var GodotArray): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc addLast(self: var GodotArray; value: GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc addFirst(self: var GodotArray; value: GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self: var GodotArray; idx: cint) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self: var GodotArray; size: cint) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rfind(self: GodotArray; what: GodotVariant; fromIdx: cint): cint {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc sort(self: var GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc sortCustom(self: var GodotArray; obj: ptr GodotObject; funcName: GodotString) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc binarySearch(self: var GodotArray; val: ptr GodotVariant; before: bool) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc binarySearchCustom(self: var GodotArray; val: ptr GodotVariant;
+                       obj: ptr GodotObject; funcName: GodotString; before: bool) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: GodotArray): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Iterators

+
+
iterator items(self: GodotArray): GodotVariant {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator mitems(self: var GodotArray): var GodotVariant {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(self: GodotArray): tuple[key: cint, val: GodotVariant] {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
iterator mpairs(self: var GodotArray): tuple[key: cint, val: var GodotVariant] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:45 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotbase.html b/v0.7.4/godotbase.html new file mode 100644 index 0000000..0d0903d --- /dev/null +++ b/v0.7.4/godotbase.html @@ -0,0 +1,1345 @@ + + + + + + + + + + + + + + + + + +Module godotbase + + + + + + + + +
+
+

Module godotbase

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+
+

Imports

+
+math +
+
+

Procs

+
+
proc isEqualApprox(a, b: float32): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEqualApprox(a, b: float64): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc sign(a: float32): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc sign(a: float64): float64 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc stepify(value, step: float64): float64 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc stepify(value, step: float32): float32 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:40 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotcoretypes.html b/v0.7.4/godotcoretypes.html new file mode 100644 index 0000000..9189482 --- /dev/null +++ b/v0.7.4/godotcoretypes.html @@ -0,0 +1,1509 @@ + + + + + + + + + + + + + + + + + +Module godotcoretypes + + + + + + + + +
+
+

Module godotcoretypes

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+
+

Types

+
+
Color = object
+  r*: float32
+  g*: float32
+  b*: float32
+  a*: float32
+
+
+ +  Source +Edit + +
+
Vector3 = object
+  x*: float32
+  y*: float32
+  z*: float32
+
+
+ +  Source +Edit + +
+
Vector2 = object
+  x*: float32
+  y*: float32
+
+
+ +  Source +Edit + +
+
Plane = object
+  normal*: Vector3
+  d*: float32
+
+
+ +  Source +Edit + +
+
Basis = object
+  elements*: array[3, Vector3]
+
+
+ +  Source +Edit + +
+
Quat = object
+  x*: float32
+  y*: float32
+  z*: float32
+  w*: float32
+
+
+ +  Source +Edit + +
+
AABB = object
+  position*: Vector3
+  size*: Vector3
+
+
+ +  Source +Edit + +
+
Rect2 = object
+  position*: Vector2
+  size*: Vector2
+
+
+ +  Source +Edit + +
+
Transform2D = object
+  elements*: array[3, Vector2]
+
+
+ +  Source +Edit + +
+
Transform = object
+  basis*: Basis
+  origin*: Vector3
+
+
+ +  Source +Edit + +
+
RID = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
Error = 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
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:40 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotdictionaries.html b/v0.7.4/godotdictionaries.html new file mode 100644 index 0000000..1547e3d --- /dev/null +++ b/v0.7.4/godotdictionaries.html @@ -0,0 +1,1472 @@ + + + + + + + + + + + + + + + + + +Module godotdictionaries + + + + + + + + +
+
+

Module godotdictionaries

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initGodotDictionary(dest: var GodotDictionary) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotDictionary(dest: var GodotDictionary; src: GodotDictionary) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self: var GodotDictionary) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self: GodotDictionary): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEmpty(self: GodotDictionary): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc clear(self: var GodotDictionary) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: GodotDictionary; key: GodotVariant): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: GodotDictionary; keys: GodotArray): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc del(self: var GodotDictionary; key: GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotHash(self: GodotDictionary): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc keys(self: GodotDictionary): GodotArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc values(self: GodotDictionary): GodotArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: GodotDictionary; key: GodotVariant): GodotVariant {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: var GodotDictionary; key, value: GodotVariant) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc mget(self: var GodotDictionary; key: GodotVariant): ptr GodotVariant {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self, other: GodotDictionary): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc toJson(self: GodotDictionary): GodotString {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:45 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotinternal.html b/v0.7.4/godotinternal.html new file mode 100644 index 0000000..c6a0e88 --- /dev/null +++ b/v0.7.4/godotinternal.html @@ -0,0 +1,1523 @@ + + + + + + + + + + + + + + + + + +Module godotinternal + + + + + + + + +
+
+

Module godotinternal

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc getMethod(className: cstring; methodName: cstring): ptr GodotMethodBind {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc ptrCall(methodBind: ptr GodotMethodBind; instance: ptr GodotObject;
+            args: ptr array[MAX_ARG_COUNT, pointer]; ret: pointer) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc call(methodBind: ptr GodotMethodBind; instance: ptr GodotObject;
+         args: ptr array[MAX_ARG_COUNT, ptr GodotVariant]; argCount: cint;
+         callError: var VariantCallError): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc nativeScriptRegisterClass(libHandle: pointer; name, base: cstring;
+                              createFunc: GodotInstanceCreateFunc;
+                              destroyFunc: GodotInstanceDestroyFunc) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc nativeScriptRegisterToolClass(libHandle: pointer; name, base: cstring;
+                                  createFunc: GodotInstanceCreateFunc;
+                                  destroyFunc: GodotInstanceDestroyFunc) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc nativeScriptRegisterMethod(libHandle: pointer; name: cstring;
+                               function_name: cstring;
+                               attr: GodotMethodAttributes;
+                               meth: GodotInstanceMethod) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc nativeScriptRegisterProperty(libHandle: pointer; name, path: cstring;
+                                 attr: ptr GodotPropertyAttributes;
+                                 setFunc: GodotPropertySetFunc;
+                                 getFunc: GodotPropertyGetFunc) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc nativeScriptRegisterSignal(libHandle: pointer; name: cstring;
+                               signal: GodotSignal) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getUserdata(instance: ptr GodotObject): pointer {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getClassConstructor(className: cstring): GodotClassConstructor {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(o: ptr GodotObject) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotPrintError(description, function, file: cstring; line: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotPrintWarning(description, function, file: cstring; line: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotPrint(message: GodotString) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getClassName(o: ptr GodotObject): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getGodotSingleton(name: cstring): ptr GodotObject {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotAlloc(bytes: cint): pointer {.
inline, raises: [], tags: []
.}
+
+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. +  Source +Edit + +
+
proc godotRealloc(p: pointer; bytes: cint): pointer {.
inline, raises: [], tags: []
.}
+
+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. +  Source +Edit + +
+
proc godotFree(p: pointer) {.
inline, raises: [], tags: []
.}
+
+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. +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:36 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotinternaltypes.html b/v0.7.4/godotinternaltypes.html new file mode 100644 index 0000000..cf64285 --- /dev/null +++ b/v0.7.4/godotinternaltypes.html @@ -0,0 +1,1941 @@ + + + + + + + + + + + + + + + + + +Module godotinternaltypes + + + + + + + + +
+
+

Module godotinternaltypes

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+
+

Types

+
+
GodotArray = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotDictionary = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotNodePath = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotObject = object
+
+ +  Source +Edit + +
+
GodotPoolByteArray = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotPoolIntArray = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotPoolRealArray = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotPoolStringArray = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotPoolVector2Array = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotPoolVector3Array = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotPoolColorArray = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotString = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
GodotCharString = object
+  data: array[sizeof(int), byte]
+
+
+ +  Source +Edit + +
+
VariantType = enum
+  Nil,                        ## atomic types
+  Bool, Int, Real, String, Vector2, ## 5
+  Rect2, Vector3, Transform2D, Plane, Quat, ## 10
+  AABB, Basis, Transform,       ## misc types
+  Color, NodePath,             ## 15
+  RID, Object, Dictionary, Array, ## 20
+  PoolByteArray, PoolIntArray, PoolRealArray, PoolStringArray, PoolVector2Array, ## 25
+  PoolVector3Array, PoolColorArray
+
+ +  Source +Edit + +
+
VariantCallErrorType = enum
+  OK, InvalidMethod, InvalidArgument, TooManyArguments, TooFewArguments,
+  InstanceIsNull
+
+ +  Source +Edit + +
+
VariantCallError = object
+  error*: VariantCallErrorType
+  argument*: cint
+  expected*: VariantType
+
+
+ +  Source +Edit + +
+
GodotVariant = object
+  data: array[4 + 2, float32]
+
+
+ +  Source +Edit + +
+
GodotMethodBind = object
+
+ +  Source +Edit + +
+
GDNativeAPIVersion = object
+  major*: cuint
+  minor*: cuint
+
+
+ +  Source +Edit + +
+
GDNativeInitOptions = object
+  inEditor*: bool
+  coreApiHash*: uint64
+  editorApiHash*: uint64
+  noApiHash*: uint64
+  reportVersionMismatch*: proc (library: ptr GodotObject; extension: cstring;
+                              want: GDNativeAPIVersion; have: GDNativeAPIVersion) {.

+      noconv
.}
+  reportLoadingError*: proc (library: ptr GodotObject; what: cstring) {.
noconv
.}
+  gdNativeLibrary*: ptr GodotObject
+  gdNativeAPIStruct*: pointer
+  activeLibraryPath*: ptr GodotString
+
+
+ +  Source +Edit + +
+
GDNativeTerminateOptions = object
+  inEditor*: bool
+
+
+ +  Source +Edit + +
+
GodotMethodRPCMode = enum
+  Disabled, Remote, Sync, Master, Slave
+
+ +  Source +Edit + +
+
GodotMethodAttributes = object
+  rpcMode*: GodotMethodRPCMode
+
+
+ +  Source +Edit + +
+
GodotPropertyHint = 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
+
+ +  Source +Edit + +
+
GodotPropertyUsage = 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
+
+ +  Source +Edit + +
+
GodotPropertyAttributes = object
+  rsetType*: GodotMethodRPCMode
+  typ*: cint
+  hint*: GodotPropertyHint
+  hintString*: GodotString
+  usage*: cint
+  defaultValue*: GodotVariant
+
+
+ +  Source +Edit + +
+
GodotInstanceCreateFunc = object
+  createFunc*: proc (obj: ptr GodotObject; methodData: pointer): pointer {.
noconv
.}
+  methodData*: pointer
+  freeFunc*: proc (a2: pointer) {.
noconv
.}
+
+
+returns user data +  Source +Edit + +
+
GodotInstanceDestroyFunc = object
+  destroyFunc*: proc (obj: ptr GodotObject; methodData: pointer; userData: pointer) {.

+      noconv
.}
+  methodData*: pointer
+  freeFunc*: proc (a2: pointer) {.
noconv
.}
+
+
+ +  Source +Edit + +
+
GodotInstanceMethod = 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
.}
+
+
+ +  Source +Edit + +
+
GodotPropertySetFunc = object
+  setFunc*: proc (obj: ptr GodotObject; methodData: pointer; userData: pointer;
+                value: GodotVariant) {.
noconv
.}
+  methodData*: pointer
+  freeFunc*: proc (a2: pointer) {.
noconv
.}
+
+
+ +  Source +Edit + +
+
GodotPropertyGetFunc = object
+  getFunc*: proc (obj: ptr GodotObject; methodData: pointer; userData: pointer): GodotVariant {.

+      noconv
.}
+  methodData*: pointer
+  freeFunc*: proc (a2: pointer) {.
noconv
.}
+
+
+ +  Source +Edit + +
+
GodotSignalArgument = object
+  name*: GodotString
+  typ*: cint
+  hint*: GodotPropertyHint
+  hintString*: GodotString
+  usage*: cint
+  defaultValue*: GodotVariant
+
+
+ +  Source +Edit + +
+
GodotSignal = object
+  name*: GodotString
+  numArgs*: cint
+  args*: ptr GodotSignalArgument
+  numDefaultArgs*: cint
+  defaultArgs*: ptr GodotVariant
+
+
+ +  Source +Edit + +
+
GodotClassConstructor = proc (): ptr GodotObject {.
noconv, gcsafe, locks: 0, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Consts

+
+
MAX_ARG_COUNT = 256
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:46 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotmacros.html b/v0.7.4/godotmacros.html new file mode 100644 index 0000000..f836492 --- /dev/null +++ b/v0.7.4/godotmacros.html @@ -0,0 +1,1319 @@ + + + + + + + + + + + + + + + + + +Module godotmacros + + + + + + + + +
+
+

Module godotmacros

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Macros

+
+
macro gdobj(definition: untyped; body: typed): typed {.
immediate
.}
+
+Generates Godot type. Self-documenting example:
import godot, node
+
+gdobj MyObj of Node:
+  var myField: int
+    ## Not exported to Godot (i.e. editor will not see this field).
+  
+  var myString* {.gdExport, hint: Length, hintStr: "20".}: string
+    ## Exported to Godot as ``my_string``.
+    ## Editor will limit this string to length 20.
+    ## ``hint` is a value of ``GodotPropertyHint`` enum.
+    ## ``hintStr`` depends on the value of ``hint``, its format is
+    ## described in ``GodotPropertyHint`` documentation.
+  
+  method ready*() =
+    ## Exported methods are exported to Godot by default,
+    ## and their Godot names are prefixed with ``_``
+    ## (in this case ``_ready``)
+    print("I am ready! myString is: " & myString)
+  
+  proc myProc*() {.gdExport.} =
+    ## Exported to Godot as ``my_proc``
+    print("myProc is called! Incrementing myField.")
+    inc myField

If parent type is omitted, the type is inherited from Object.

+

tool specifier can be added to mark the type as an editor plugin:

+
import godot, editor_plugin
+
+gdobj(MyTool of EditorPlugin, tool):
+  method enterTree*() =
+    print("MyTool initialized!")

Objects can be instantiated by invoking gdnew or by using load or any other way that you can find in Godot API.

+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:48 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotnim.html b/v0.7.4/godotnim.html new file mode 100644 index 0000000..4c30ea4 --- /dev/null +++ b/v0.7.4/godotnim.html @@ -0,0 +1,1996 @@ + + + + + + + + + + + + + + + + + +Module godotnim + + + + + + + + +
+
+

Module godotnim

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

This module defines NimGodotObject and toVariant/fromVariant converters for Nim types. The converters are used by gdobj macro to import/export values from/to Godot (editor, GDScript).

+

You can also allow conversion of any custom type MyType by implementing:

+
proc godotTypeInfo*(T: typedesc[MyType]): GodotTypeInfo
+proc toVariant*(self: MyType): Variant
+proc fromVariant*(self: var MyType, val: Variant): ConversionResult

Implementing godotTypeInfo is optional and is necessary only if you want the type to be editable from the editor.

+

+ +
+

Types

+
+
NimGodotObject = ref object of RootObj
+  godotObject: ptr GodotObject
+  linkedObject: NimGodotObject ## Wrapper around native object that is the container of the Nim "script"
+                             ## This is needed for `of` checks and `as` conversions to work as
+                             ## expected. For example, Nim type may inherit from ``Spatial``, but the
+                             ## script is attached to ``Particles``. In this case conversion to
+                             ## ``Particles`` is valid, but Nim type system is not aware of that.
+                             ## This works in both directions - for linked native object this
+                             ## reference points to Nim object.
+  isRef*: bool
+  isFinalized: bool
+  isNative: bool
+
+
+The base type all Godot types inherit from. Manages lifecycle of the wrapped GodotObject. +  Source +Edit + +
+
ConversionResult = enum
+  OK, TypeError,               ## Type mismatch
+  RangeError                  ## Types match, but the value is out of range.
+            ## Mainly used for numeric (ordinal) types.
+
+Conversion result to return from fromVariant procedure. +  Source +Edit + +
+
CallError = object of Exception
+  err*: VariantCallError       ## The error as returned by Godot
+
+
+Raised by wrappers in case of an incorrect dynamic invocation. For example, if incorrect number of arguments were passed or they had unexpected types. +  Source +Edit + +
+
GodotTypeInfo = object
+  variantType*: VariantType
+  hint*: GodotPropertyHint
+  hintStr*: string ## Format depends on the type and the hint.
+                 ## For example, for Enum ``hint`` this is a comma separated list of
+                 ## values.
+                 ## See documentation of ``GodotPropertyHint`` for description of formats.
+
+
+Type information provided to Godot editor +  Source +Edit + +
+ +
+
+

Vars

+
+
classRegistryStatic: TableRef[cstring, ObjectInfo]
+
+Compile-time variable used for implementation of several procedures and macros +  Source +Edit + +
+
refClasses = newSeq(0)
+
+ +  Source +Edit + +
+ +
+
+

Procs

+
+
proc isFinalized(obj: NimGodotObject): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc print(parts: varargs[string, `$`]) {.
raises: [], tags: []
.}
+
+Prints concatenated parts to Godot log. +  Source +Edit + +
+
proc getClassName(o: NimGodotObject): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(obj: NimGodotObject) {.
raises: [], tags: []
.}
+
+Destroy the object. You only need to call this for objects not inherited from Reference, where manual lifecycle control is necessary. +  Source +Edit + +
+
proc nimGodotObjectFinalizer[T: NimGodotObject](obj: T)
+
+ +  Source +Edit + +
+
proc asNimGodotObject[T: NimGodotObject](godotObject: ptr GodotObject;
+                                       forceNativeObject, noRef: bool = false): T
+
+Wraps godotObject into Nim type T. This is used by godotapigen and should rarely be used by anything else. +  Source +Edit + +
+
proc newVariant(obj: NimGodotObject): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asObject[T: NimGodotObject](v: Variant): T {.
inline
.}
+
+Converts v to object of type T. Returns nil if the conversion cannot be performed (v's type is not an Object or it's an object of an incompatible type) +  Source +Edit + +
+
proc asObject(v: Variant; T: typedesc[NimGodotObject]): T:type {.
inline
.}
+
+Converts v to object of type T. Returns nil if the conversion cannot be performed (v's type is not an Object or it's an object of an incompatible type) +  Source +Edit + +
+
proc `as`[T: NimGodotObject](obj: NimGodotObject; t: typedesc[T]): T
+
+

Converts the obj into the specified type. Returns nil if the conversion cannot be performed (the obj is not of the type T)

+

This can be used either in dot notation (node.as(Button)) or infix notation (node as Button).

+ +  Source +Edit + +
+
proc `of`[T: NimGodotObject](obj: NimGodotObject; t: typedesc[T]): bool {.
inline
.}
+
+Godot-specific inheritance check. +  Source +Edit + +
+
proc getSingleton[T: NimGodotObject](): T
+
+Returns singleton of type T. Normally, this should not be used, because godotapigen wraps singleton methods so that singleton objects don't have to be provided as parameters. +  Source +Edit + +
+
proc gdnew[T: NimGodotObject](): T
+
+Instantiates new object of type T. +  Source +Edit + +
+
proc newCallError(err: VariantCallError): ref CallError {.
raises: [], tags: []
.}
+
+Instantiates CallError from Godot err. +  Source +Edit + +
+
proc newConversionError(err: ConversionResult): ref ValueError {.
raises: [], tags: []
.}
+
+Instantiates error raised by godotapigen generated code in case of a conversion error. +  Source +Edit + +
+
proc setGodotObject(nimObj: NimGodotObject; obj: ptr GodotObject) {.
inline, raises: [],
+    tags: []
.}
+
+Used from Godot constructor produced by gdobj macro. Do not call. +  Source +Edit + +
+
proc setNativeObject(nimObj: NimGodotObject; nativeObj: NimGodotObject) {.
inline,
+    raises: [], tags: []
.}
+
+Used from Godot constructor produced by gdobj macro. Do not call. +  Source +Edit + +
+
proc removeGodotObject(nimObj: NimGodotObject) {.
inline, raises: [], tags: []
.}
+
+Used from Godot destructor produced by gdobj macro. Do not call. +  Source +Edit + +
+
proc `==`(self, other: NimGodotObject): bool {.
inline, raises: [], tags: []
.}
+
+Compares objects by referential equality. +  Source +Edit + +
+
proc godotObject(nimObj: NimGodotObject): ptr GodotObject {.
inline, raises: [], tags: []
.}
+
+Returns raw poitner to GodotObject. Use only if you know what you are doing. +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[NimGodotObject]): GodotTypeInfo {.
inline
.}
+
+ +  Source +Edit + +
+
proc toVariant(self: NimGodotObject): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc fromVariant[T: NimGodotObject](self: var T; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc toVariant(self: Variant): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc fromVariant(self: var Variant; val: Variant): ConversionResult {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[SomeGodotOrNum]): GodotTypeInfo {.
inline
.}
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[range]): VariantType {.
inline
.}
+
+ +  Source +Edit + +
+
proc toVariant[T: SomeGodotOrNum](val: T): Variant {.
inline
.}
+
+ +  Source +Edit + +
+
proc fromVariant[T: SomeSignedInt or SomeUnsignedInt](self: var T; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[enum]): GodotTypeInfo
+
+ +  Source +Edit + +
+
proc toVariant[T: enum](self: T): Variant {.
inline
.}
+
+ +  Source +Edit + +
+
proc fromVariant[T: enum](self: var T; val: Variant): ConversionResult {.
inline
.}
+
+ +  Source +Edit + +
+
proc fromVariant[T: SomeFloat](self: var T; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc fromVariant[T: SomeGodot](self: var T; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[string]): GodotTypeInfo {.
inline
.}
+
+ +  Source +Edit + +
+
proc toVariant(s: string): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc fromVariant(s: var string; val: Variant): ConversionResult {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[seq]): GodotTypeInfo
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[array]): GodotTypeInfo
+
+ +  Source +Edit + +
+
proc toVariant[T](s: seq[T]): Variant
+
+ +  Source +Edit + +
+
proc toVariant[I, T](s: array[I, T]): Variant
+
+ +  Source +Edit + +
+
proc fromVariant[T](s: var seq[T]; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc fromVariant[T: array](s: var T; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc godotTypeInfo(T: typedesc[Table | TableRef]): GodotTypeInfo {.
inline
.}
+
+ +  Source +Edit + +
+
proc toVariant[T: Table or TableRef](t: T): Variant
+
+ +  Source +Edit + +
+
proc fromVariant[T: Table or TableRef](t: var T; val: Variant): ConversionResult
+
+ +  Source +Edit + +
+
proc getNativeLibHandle(): pointer {.
raises: [], tags: []
.}
+
+Returns NativeScript library handle used to register type information in Godot. +  Source +Edit + +
+
proc registerFrameCallback(cb: proc () {.
closure
.}) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Templates

+
+
template printWarning(warning: typed)
+
+Prints warning to Godot log, adding filename and line information. +  Source +Edit + +
+
template printError(error: typed)
+
+Prints error to Godot log, adding filename and line information. +  Source +Edit + +
+
template registerClass(T: typedesc; godotClassName: cstring; native: bool)
+
+Registers the specified Godot type. Used by gdobj macro and godotapigen. +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:49 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotnodepaths.html b/v0.7.4/godotnodepaths.html new file mode 100644 index 0000000..548a251 --- /dev/null +++ b/v0.7.4/godotnodepaths.html @@ -0,0 +1,1415 @@ + + + + + + + + + + + + + + + + + +Module godotnodepaths + + + + + + + + +
+
+

Module godotnodepaths

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initGodotNodePath(dest: var GodotNodePath; s: GodotString) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotNodePath(dest: var GodotNodePath; src: GodotNodePath) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self: var GodotNodePath) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc toGodotString(self: GodotNodePath): GodotString {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isAbsolute(self: GodotNodePath): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc nameCount(self: GodotNodePath): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getName(self: GodotNodePath; idx: cint): GodotString {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc subnameCount(self: GodotNodePath): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getSubname(self: GodotNodePath; idx: cint): GodotString {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc getConcatenatedSubnames(self: GodotNodePath): GodotString {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc isEmpty(self: GodotNodePath): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: GodotNodePath): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:46 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotpoolarrays.html b/v0.7.4/godotpoolarrays.html new file mode 100644 index 0000000..880e25c --- /dev/null +++ b/v0.7.4/godotpoolarrays.html @@ -0,0 +1,2532 @@ + + + + + + + + + + + + + + + + + +Module godotpoolarrays + + + + + + + + +
+
+

Module godotpoolarrays

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initGodotPoolByteArray(dest122068: var GodotPoolByteArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolByteArray(dest122070: var GodotPoolByteArray;
+                           src122072: GodotPoolByteArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolByteArray(dest122074: var GodotPoolByteArray; arr122076: GodotArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122078: var GodotPoolByteArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122080: var GodotPoolByteArray; data122082: byte) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122084: var GodotPoolByteArray; arr122086: GodotPoolByteArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122088: var GodotPoolByteArray; idx122090: cint; data122092: byte): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122094: var GodotPoolByteArray; idx122096: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122098: var GodotPoolByteArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122100: var GodotPoolByteArray; size122102: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122104: var GodotPoolByteArray; idx122106: cint; data122108: byte) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122110: GodotPoolByteArray; idx122112: cint): byte {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122114: GodotPoolByteArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolIntArray(dest122216: var GodotPoolIntArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolIntArray(dest122218: var GodotPoolIntArray; src122220: GodotPoolIntArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolIntArray(dest122222: var GodotPoolIntArray; arr122224: GodotArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122226: var GodotPoolIntArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122228: var GodotPoolIntArray; data122230: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122232: var GodotPoolIntArray; arr122234: GodotPoolIntArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122236: var GodotPoolIntArray; idx122238: cint; data122240: cint): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122242: var GodotPoolIntArray; idx122244: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122246: var GodotPoolIntArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122248: var GodotPoolIntArray; size122250: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122252: var GodotPoolIntArray; idx122254: cint; data122256: cint) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122258: GodotPoolIntArray; idx122260: cint): cint {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122262: GodotPoolIntArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolRealArray(dest122352: var GodotPoolRealArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolRealArray(dest122354: var GodotPoolRealArray;
+                           src122356: GodotPoolRealArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolRealArray(dest122358: var GodotPoolRealArray; arr122360: GodotArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122362: var GodotPoolRealArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122364: var GodotPoolRealArray; data122366: float32) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122368: var GodotPoolRealArray; arr122370: GodotPoolRealArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122372: var GodotPoolRealArray; idx122374: cint; data122376: float32): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122378: var GodotPoolRealArray; idx122380: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122382: var GodotPoolRealArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122384: var GodotPoolRealArray; size122386: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122388: var GodotPoolRealArray; idx122390: cint; data122392: float32) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122394: GodotPoolRealArray; idx122396: cint): float32 {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122398: GodotPoolRealArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolStringArray(dest122488: var GodotPoolStringArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolStringArray(dest122490: var GodotPoolStringArray;
+                             src122492: GodotPoolStringArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolStringArray(dest122494: var GodotPoolStringArray; arr122496: GodotArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122498: var GodotPoolStringArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122500: var GodotPoolStringArray; data122502: GodotString) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122504: var GodotPoolStringArray; arr122506: GodotPoolStringArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122508: var GodotPoolStringArray; idx122510: cint; data122512: GodotString): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122514: var GodotPoolStringArray; idx122516: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122518: var GodotPoolStringArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122520: var GodotPoolStringArray; size122522: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122524: var GodotPoolStringArray; idx122526: cint; data122528: GodotString) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122530: GodotPoolStringArray; idx122532: cint): GodotString {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122534: GodotPoolStringArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolVector2Array(dest122624: var GodotPoolVector2Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolVector2Array(dest122626: var GodotPoolVector2Array;
+                              src122628: GodotPoolVector2Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolVector2Array(dest122630: var GodotPoolVector2Array;
+                              arr122632: GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122634: var GodotPoolVector2Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122636: var GodotPoolVector2Array; data122638: Vector2) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122640: var GodotPoolVector2Array; arr122642: GodotPoolVector2Array) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122644: var GodotPoolVector2Array; idx122646: cint; data122648: Vector2): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122650: var GodotPoolVector2Array; idx122652: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122654: var GodotPoolVector2Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122656: var GodotPoolVector2Array; size122658: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122660: var GodotPoolVector2Array; idx122662: cint; data122664: Vector2) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122666: GodotPoolVector2Array; idx122668: cint): Vector2 {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122670: GodotPoolVector2Array): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolVector3Array(dest122760: var GodotPoolVector3Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolVector3Array(dest122762: var GodotPoolVector3Array;
+                              src122764: GodotPoolVector3Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolVector3Array(dest122766: var GodotPoolVector3Array;
+                              arr122768: GodotArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122770: var GodotPoolVector3Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122772: var GodotPoolVector3Array; data122774: Vector3) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122776: var GodotPoolVector3Array; arr122778: GodotPoolVector3Array) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122780: var GodotPoolVector3Array; idx122782: cint; data122784: Vector3): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122786: var GodotPoolVector3Array; idx122788: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122790: var GodotPoolVector3Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122792: var GodotPoolVector3Array; size122794: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122796: var GodotPoolVector3Array; idx122798: cint; data122800: Vector3) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122802: GodotPoolVector3Array; idx122804: cint): Vector3 {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122806: GodotPoolVector3Array): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolColorArray(dest122896: var GodotPoolColorArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolColorArray(dest122898: var GodotPoolColorArray;
+                            src122900: GodotPoolColorArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotPoolColorArray(dest122902: var GodotPoolColorArray; arr122904: GodotArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self122906: var GodotPoolColorArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122908: var GodotPoolColorArray; data122910: Color) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self122912: var GodotPoolColorArray; arr122914: GodotPoolColorArray) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self122916: var GodotPoolColorArray; idx122918: cint; data122920: Color): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self122922: var GodotPoolColorArray; idx122924: cint) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self122926: var GodotPoolColorArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self122928: var GodotPoolColorArray; size122930: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self122932: var GodotPoolColorArray; idx122934: cint; data122936: Color) {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self122938: GodotPoolColorArray; idx122940: cint): Color {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self122942: GodotPoolColorArray): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Iterators

+
+
iterator items(arr122116: GodotPoolByteArray): byte {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122120: GodotPoolByteArray): tuple[key: cint, val: byte] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr122264: GodotPoolIntArray): cint {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122268: GodotPoolIntArray): tuple[key: cint, val: cint] {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr122400: GodotPoolRealArray): float32 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122404: GodotPoolRealArray): tuple[key: cint, val: float32] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr122536: GodotPoolStringArray): GodotString {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122540: GodotPoolStringArray): tuple[key: cint, val: GodotString] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr122672: GodotPoolVector2Array): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122676: GodotPoolVector2Array): tuple[key: cint, val: Vector2] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr122808: GodotPoolVector3Array): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122812: GodotPoolVector3Array): tuple[key: cint, val: Vector3] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr122944: GodotPoolColorArray): Color {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr122948: GodotPoolColorArray): tuple[key: cint, val: Color] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:46 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotstrings.html b/v0.7.4/godotstrings.html new file mode 100644 index 0000000..5c5b2c6 --- /dev/null +++ b/v0.7.4/godotstrings.html @@ -0,0 +1,1356 @@ + + + + + + + + + + + + + + + + + +Module godotstrings + + + + + + + + +
+
+

Module godotstrings

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc `==`(self, b: GodotString): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(self, b: GodotString): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `&`(self, b: GodotString): GodotString {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(self: var GodotString) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: GodotString): string {.
raises: [], tags: []
.}
+
+Converts the GodotString into Nim string +  Source +Edit + +
+
proc toGodotString(s: string): GodotString {.
inline, raises: [], tags: []
.}
+
+Converts the Nim string into GodotString +  Source +Edit + +
+
proc toGodotString(s: cstring): GodotString {.
inline, raises: [], tags: []
.}
+
+Converts the cstring into GodotString +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:47 UTC +
+
+
+
+ + + diff --git a/v0.7.4/godotvariants.html b/v0.7.4/godotvariants.html new file mode 100644 index 0000000..b692eb4 --- /dev/null +++ b/v0.7.4/godotvariants.html @@ -0,0 +1,2026 @@ + + + + + + + + + + + + + + + + + +Module godotvariants + + + + + + + + +
+
+

Module godotvariants

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc getType(p: GodotVariant): VariantType {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; src: GodotVariant) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; b: bool) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; i: uint64) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; i: int64) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; r: cdouble) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; s: GodotString) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; v2: Vector2) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; rect2: Rect2) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; v3: Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; t2d: Transform2D) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; plane: Plane) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; quat: Quat) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; aabb: AABB) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; basis: Basis) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; trans: Transform) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; color: Color) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; nodePath: GodotNodePath) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; rid: RID) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; obj: ptr GodotObject) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; arr: GodotArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; pba: GodotPoolByteArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; pia: GodotPoolIntArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; pra: GodotPoolRealArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; psa: GodotPoolStringArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; pv2a: GodotPoolVector2Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; pv3a: GodotPoolVector3Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; pca: GodotPoolColorArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initGodotVariant(dest: var GodotVariant; dict: GodotDictionary) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc deinit(v: var GodotVariant) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asBool(self: GodotVariant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asUInt(self: GodotVariant): uint64 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asInt(self: GodotVariant): int64 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asReal(self: GodotVariant): cdouble {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotString(self: GodotVariant): GodotString {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asVector2(self: GodotVariant): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asRect2(self: GodotVariant): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asVector3(self: GodotVariant): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asTransform2D(self: GodotVariant): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asPlane(self: GodotVariant): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asQuat(self: GodotVariant): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asAABB(self: GodotVariant): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asBasis(self: GodotVariant): Basis {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asTransform(self: GodotVariant): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asColor(self: GodotVariant): Color {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asNodePath(self: GodotVariant): GodotNodePath {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asRID(self: GodotVariant): RID {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotObject(self: GodotVariant): ptr GodotObject {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotArray(self: GodotVariant): GodotArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolByteArray(self: GodotVariant): GodotPoolByteArray {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolIntArray(self: GodotVariant): GodotPoolIntArray {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolRealArray(self: GodotVariant): GodotPoolRealArray {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolStringArray(self: GodotVariant): GodotPoolStringArray {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolVector2Array(self: GodotVariant): GodotPoolVector2Array {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolVector3Array(self: GodotVariant): GodotPoolVector3Array {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotPoolColorArray(self: GodotVariant): GodotPoolColorArray {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotDictionary(self: GodotVariant): GodotDictionary {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc call(self: var GodotVariant; meth: GodotString;
+         args: ptr array[256, ptr GodotVariant]; argCount: cint;
+         error: var VariantCallError): GodotVariant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hasMethod(self: GodotVariant; meth: GodotString): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self, other: GodotVariant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(self, other: GodotVariant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hashCompare(self, other: GodotVariant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc booleanize(self: GodotVariant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: GodotVariant): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:47 UTC +
+
+
+
+ + + diff --git a/v0.7.4/index.html b/v0.7.4/index.html new file mode 100644 index 0000000..916a591 --- /dev/null +++ b/v0.7.4/index.html @@ -0,0 +1,1320 @@ + + + + + + + + + + + + + + + + + +Nim bindings for Godot Engine + + + + + + + + +
+
+

Nim bindings for Godot Engine

+
+
+
+ Search: +
+ + +
+
+
+

+ + +
Author: Ruslan Mustakov
Version: 0.7.4
GitHub: https://github.com/pragmagic/godot-nim

godot-nim library allows to create games on Godot Engine with Nim programming language. Nim is a statically typed language with an elegant Python-like syntax that compiles to native code. It is garbage-collected, but its GC supports real-time mode which this library makes use of. It means the GC will never run during game frames and will use fixed amount of frame idle time to collect garbage. This leads to no stalls and close to zero compromise on performance comparing to native languages with manual memory management.

+

If you are not familiar with Nim yet, it is recommended to go through the official tutorial.

+

VSCode is the recommended editor for working with Nim code. It is cross-platform and has the excellent nim plugin that supports most of the features you would expect from an IDE. It also has godot-tools plugin which adds features for editing GDScript and Godot resource files.

+ +

Getting Started

+

Building Godot

The library requires a not yet released Godot version 3.0, which you can build yourself by running the commands below (requires Git, Python 2.7, SCons):

+
git clone https://github.com/godotengine/godot.git
+cd godot
+scons platform=<your_platform>

where <your_platform> can be windows, osx, x11. After build is finished, Godot binaries will be under the bin folder. More details about compiling Godot can be found in Godot documentation.

+ +

Installing Nim

The library requires Nim version 0.18.0 or newer, which you can get here: https://nim-lang.org/install.html

+

Make sure you also have nimble (Nim's package manager) installed.

+ +

Creating Project

The fastest way to set up a Godot-Nim project is to use an existing stub:

+
git clone --depth=1 https://github.com/pragmagic/godot-nim-stub.git myproject

(you can then delete the .git directory within to untie the project from the stub repository)

+

The stub contains the necessary build configuration to compile your code for desktop and mobile platforms, as well as a couple of very simple scenes to help you get started. Consult the stub's README for information about compiling the project.

+ +

Adding Nim to Existing Project

If you would like to use Nim in an existing project:

+
  1. Copy nakefile.nim file and src directory from the stub described in the previous section above your Godot project folder. Adjust paths in build scripts (nakefile.nim, src/stub.nimble) according to your own project structure.
    2. +
  2. Copy project/nimlib.tres to your Godot project folder. It is a GDNative library resource that contains paths to dynamic libraries compiled by Nim.
    3. +
+ +

Next Steps

Once you are familiarized with the build process (it's as simple as running nake build after you are set up), it is recommended to go through godotmacros and godotnim module documentations. They describe special macros and procedures needed to define or instantiate Godot objects. After you learned that, the rest is similar to using any Nim library. These bindings do not limit any of Nim's capabilities, and you can use any Nim types as fields or parameters of Godot objects and their procedures (but, obviously, you may not be able to export some of them to Godot editor or GDScript, unless you define your own converters).

+ +

Modules

The binding library consists of three major modules:

+
  • godot - Contains core types and macro definitions. You need to import this in any module that defines or makes use of Godot types.
    • +
  • godotinternal - Contains raw wrappers over few core types, such as GodotVariant, GodotString, GodotNodePath, GodotDictionary, pool arrays. These are used by godotapigen and macro implementations, and you don't have to use them at all in your code, unless you want to go into low-level details for some reason. Each of those types needs to be destructed manually with deinit procedure.
    • +
  • godotapigen - Wrapper generator based on data from Godot's ClassDB. You only need to use it as a part of the build process.
    • +
+ +

godot Module

Contains core types and macro definitions. You need to import this in any module that defines or makes use of Godot types. The sumbodules below are exported and you don't have to import any of them directly.

+
  • godotnim Defines NimGodotObject and Varaint converters for standard Nim types.
    • +
  • godotmacros Defines gdobj macro for defining Godot objects.
    • +
  • variants Variant type represents a "dynamic object" that many Godot procedures make use of.
    • +
  • arrays Defines Array of Variants.
    • +
  • basis Defines 3D Basis.
    • +
  • colors Defines ARGB Color.
    • +
  • dictionaries Defines Variant -> Variant Dictionary.
    • +
  • nodepaths Defines NodePath - a path to a Node.
    • +
  • planes Defines 3D Plane.
    • +
  • poolarrays Defines pooled arrays: PoolByteArray, PoolIntArray, PoolRealArray, PoolVector2Array, PoolVector3Array, PoolColorArray, PoolStringArray.
    • +
  • quats Defines Quat (quaternion) describing object rotation in 3D space.
    • +
  • rect2 Defines Rect2 - a 2D rectangle.
    • +
  • aabb Defines AABB - a 3D box.
    • +
  • rids Defines RID - a resource identifier.
    • +
  • transform2d Defines Transform2D.
    • +
  • transforms Defines Transform.
    • +
  • vector2 Defines Vector2.
    • +
  • vector3 Defines Vector3.
    • +
  • godotbase Defines Error type and few common math procedures missing in Nim's standard library.
    • +
+ +

Godot API

This is an auto-generated list of Godot API modules. It's built from Godot changeset 8afe5b4d9fa50d807f79006ab457c41e4de83247.

+ +

godotinternal Module

Contains low-level wrappers over Godot types that require manual memory management. This module is used within godot-nim implementation and you don't need to import it unless you know what you are doing.

+ +

+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 13:13:06 UTC +
+
+
+
+ + + diff --git a/v0.7.4/nodepaths.html b/v0.7.4/nodepaths.html new file mode 100644 index 0000000..ab73336 --- /dev/null +++ b/v0.7.4/nodepaths.html @@ -0,0 +1,1458 @@ + + + + + + + + + + + + + + + + + +Module nodepaths + + + + + + + + +
+
+

Module nodepaths

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Types

+
+
NodePath = ref object
+  path: GodotNodePath
+
+
+ +  Source +Edit + +
+ +
+
+

Procs

+
+
proc newNodePath(path: GodotNodePath): NodePath {.
raises: [], tags: []
.}
+
+Moves the GodotNodePath into Nim wrapper. The path will be destroyed automatically when the result is no longer referenced. +  Source +Edit + +
+
proc newNodePath(s: string): NodePath {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc godotNodePath(path: NodePath): ptr GodotNodePath {.
inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of path +  Source +Edit + +
+
proc `$`(self: NodePath): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isAbsolute(self: NodePath): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc nameCount(self: NodePath): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getName(self: NodePath; idx: int): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc subnameCount(self: NodePath): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getSubname(self: NodePath; idx: int): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getConcatenatedSubnames(self: NodePath): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isEmpty(self: NodePath): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: NodePath): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Converters

+
+
converter fromString(s: string): NodePath {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:40 UTC +
+
+
+
+ + + diff --git a/v0.7.4/planes.html b/v0.7.4/planes.html new file mode 100644 index 0000000..587f559 --- /dev/null +++ b/v0.7.4/planes.html @@ -0,0 +1,1460 @@ + + + + + + + + + + + + + + + + + +Module planes + + + + + + + + +
+
+

Module planes

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initPlane(a, b, c, d: float32): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initPlane(v1, v2, v3: Vector3): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initPlane(normal: Vector3; d: float32): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Plane): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc normalized(self: Plane): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc center(self: Plane): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc getAnyPoint(self: Plane): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isPointOver(self: Plane; point: Vector3): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc distanceTo(self: Plane; point: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: Plane; point: Vector3; epsilon: float32): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc project(self: Plane; point: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersect3(self: Plane; dest: var Vector3; b, c: Plane): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc intersectsRay(self: Plane; dest: var Vector3; v, dir: Vector3): bool {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersectsSegment(self: Plane; dest: var Vector3;
+                      segmentBegin, segmentEnd: Vector3): bool {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(self: Plane): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: Plane): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:41 UTC +
+
+
+
+ + + diff --git a/v0.7.4/poolarrays.html b/v0.7.4/poolarrays.html new file mode 100644 index 0000000..0f3d325 --- /dev/null +++ b/v0.7.4/poolarrays.html @@ -0,0 +1,2611 @@ + + + + + + + + + + + + + + + + + +Module poolarrays + + + + + + + + +
+
+

Module poolarrays

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Types

+
+
PoolByteArray = ref object
+  godotPoolByteArray: GodotPoolByteArray
+
+
+ +  Source +Edit + +
+
PoolIntArray = ref object
+  godotPoolIntArray: GodotPoolIntArray
+
+
+ +  Source +Edit + +
+
PoolRealArray = ref object
+  godotPoolRealArray: GodotPoolRealArray
+
+
+ +  Source +Edit + +
+
PoolVector2Array = ref object
+  godotPoolVector2Array: GodotPoolVector2Array
+
+
+ +  Source +Edit + +
+
PoolVector3Array = ref object
+  godotPoolVector3Array: GodotPoolVector3Array
+
+
+ +  Source +Edit + +
+
PoolColorArray = ref object
+  godotPoolColorArray: GodotPoolColorArray
+
+
+ +  Source +Edit + +
+
PoolStringArray = ref object
+  godotPoolStringArray: GodotPoolStringArray
+
+
+ +  Source +Edit + +
+ +
+
+

Procs

+
+
proc newPoolByteArray(): PoolByteArray {.
inline, raises: [Exception],
+                                      tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolByteArray(self125086: PoolByteArray): ptr GodotPoolByteArray {.
inline,
+    raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolByteArray(arr125088: GodotPoolByteArray): PoolByteArray {.
inline,
+    raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolIntArray(): PoolIntArray {.
inline, raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolIntArray(self125147: PoolIntArray): ptr GodotPoolIntArray {.
inline,
+    raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolIntArray(arr125149: GodotPoolIntArray): PoolIntArray {.
inline,
+    raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolRealArray(): PoolRealArray {.
inline, raises: [Exception],
+                                      tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolRealArray(self125210: PoolRealArray): ptr GodotPoolRealArray {.
inline,
+    raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolRealArray(arr125212: GodotPoolRealArray): PoolRealArray {.
inline,
+    raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolVector2Array(): PoolVector2Array {.
inline, raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolVector2Array(self125273: PoolVector2Array): ptr GodotPoolVector2Array {.

+    inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolVector2Array(arr125275: GodotPoolVector2Array): PoolVector2Array {.

+    inline, raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolVector3Array(): PoolVector3Array {.
inline, raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolVector3Array(self125336: PoolVector3Array): ptr GodotPoolVector3Array {.

+    inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolVector3Array(arr125338: GodotPoolVector3Array): PoolVector3Array {.

+    inline, raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolColorArray(): PoolColorArray {.
inline, raises: [Exception],
+                                        tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolColorArray(self125399: PoolColorArray): ptr GodotPoolColorArray {.

+    inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolColorArray(arr125401: GodotPoolColorArray): PoolColorArray {.
inline,
+    raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolStringArray(): PoolStringArray {.
inline, raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc godotPoolStringArray(self125462: PoolStringArray): ptr GodotPoolStringArray {.

+    inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of the array. +  Source +Edit + +
+
proc newPoolStringArray(arr125464: GodotPoolStringArray): PoolStringArray {.
inline,
+    raises: [Exception], tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc newPoolByteArray(arr170002: Array): PoolByteArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170004: PoolByteArray; arr170006: PoolByteArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self170008: PoolByteArray; idx170010: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self170012: PoolByteArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self170014: PoolByteArray; size170016: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self170018: PoolByteArray): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170020: PoolByteArray; data170022: uint8) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self170024: PoolByteArray; idx170026: int; data170028: uint8): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self170030: PoolByteArray; idx170032: int; data170034: uint8) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self170036: PoolByteArray; idx170038: int): uint8 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc newPoolIntArray(arr170202: Array): PoolIntArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170204: PoolIntArray; arr170206: PoolIntArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self170208: PoolIntArray; idx170210: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self170212: PoolIntArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self170214: PoolIntArray; size170216: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self170218: PoolIntArray): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170220: PoolIntArray; data170222: cint) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self170224: PoolIntArray; idx170226: int; data170228: cint): Error {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self170230: PoolIntArray; idx170232: int; data170234: cint) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self170236: PoolIntArray; idx170238: int): cint {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newPoolRealArray(arr170402: Array): PoolRealArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170404: PoolRealArray; arr170406: PoolRealArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self170408: PoolRealArray; idx170410: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self170412: PoolRealArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self170414: PoolRealArray; size170416: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self170418: PoolRealArray): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170420: PoolRealArray; data170422: float64) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self170424: PoolRealArray; idx170426: int; data170428: float64): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self170430: PoolRealArray; idx170432: int; data170434: float64) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self170436: PoolRealArray; idx170438: int): float64 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc newPoolVector2Array(arr170602: Array): PoolVector2Array {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170604: PoolVector2Array; arr170606: PoolVector2Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self170608: PoolVector2Array; idx170610: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self170612: PoolVector2Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self170614: PoolVector2Array; size170616: int) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self170618: PoolVector2Array): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170620: PoolVector2Array; data170622: Vector2) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self170624: PoolVector2Array; idx170626: int; data170628: Vector2): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self170630: PoolVector2Array; idx170632: int; data170634: Vector2) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self170636: PoolVector2Array; idx170638: int): Vector2 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc newPoolVector3Array(arr170802: Array): PoolVector3Array {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170804: PoolVector3Array; arr170806: PoolVector3Array) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self170808: PoolVector3Array; idx170810: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self170812: PoolVector3Array) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self170814: PoolVector3Array; size170816: int) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self170818: PoolVector3Array): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self170820: PoolVector3Array; data170822: Vector3) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self170824: PoolVector3Array; idx170826: int; data170828: Vector3): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self170830: PoolVector3Array; idx170832: int; data170834: Vector3) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self170836: PoolVector3Array; idx170838: int): Vector3 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc newPoolColorArray(arr171002: Array): PoolColorArray {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self171004: PoolColorArray; arr171006: PoolColorArray) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self171008: PoolColorArray; idx171010: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self171012: PoolColorArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self171014: PoolColorArray; size171016: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self171018: PoolColorArray): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self171020: PoolColorArray; data171022: Color) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self171024: PoolColorArray; idx171026: int; data171028: Color): Error {.

+    inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self171030: PoolColorArray; idx171032: int; data171034: Color) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self171036: PoolColorArray; idx171038: int): Color {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc newPoolStringArray(arr171202: Array): PoolStringArray {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self171204: PoolStringArray; arr171206: PoolStringArray) {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc delete(self171208: PoolStringArray; idx171210: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reverse(self171212: PoolStringArray) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc setLen(self171214: PoolStringArray; size171216: int) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc len(self171218: PoolStringArray): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc add(self: PoolStringArray; data: string) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc insert(self: PoolStringArray; idx: int; data: string): Error {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: PoolStringArray; idx: int; data: string) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: PoolStringArray; idx: int): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+
+

Iterators

+
+
iterator items(arr170040: PoolByteArray): uint8 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr170044: PoolByteArray): tuple[key: int, val: uint8] {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr170240: PoolIntArray): cint {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr170244: PoolIntArray): tuple[key: int, val: cint] {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr170440: PoolRealArray): float64 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr170444: PoolRealArray): tuple[key: int, val: float64] {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr170640: PoolVector2Array): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr170644: PoolVector2Array): tuple[key: int, val: Vector2] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr170840: PoolVector3Array): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr170844: PoolVector3Array): tuple[key: int, val: Vector3] {.

+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr171040: PoolColorArray): Color {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr171044: PoolColorArray): tuple[key: int, val: Color] {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
iterator items(arr: PoolStringArray): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
iterator pairs(arr: PoolStringArray): tuple[key: int, val: string] {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:41 UTC +
+
+
+
+ + + diff --git a/v0.7.4/quats.html b/v0.7.4/quats.html new file mode 100644 index 0000000..7ed1dfe --- /dev/null +++ b/v0.7.4/quats.html @@ -0,0 +1,1532 @@ + + + + + + + + + + + + + + + + + +Module quats + + + + + + + + +
+
+

Module quats

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initQuat(x, y, z, w: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initQuat(axis: Vector3; angle: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Quat): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc length(self: Quat): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc lengthSquared(self: Quat): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc normalized(self: Quat): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isNormalized(self: Quat): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc inverse(self: Quat): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc dot(a, b: Quat): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xform(self: Quat; v: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc slerp(self: Quat; b: Quat; t: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc slerpni(self: Quat; b: Quat; t: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc cubicSlerp(self, b, preA, postB: Quat; t: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(a: Quat; b: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(a: var Quat; b: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+`(a, b: Quat): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+=`(a: var Quat; b: Quat) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(a, b: Quat): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-=`(a: var Quat; b: Quat) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/`(self: Quat; b: float32): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/=`(self: var Quat; b: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: Quat): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(self: Quat): Quat {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:42 UTC +
+
+
+
+ + + diff --git a/v0.7.4/rect2.html b/v0.7.4/rect2.html new file mode 100644 index 0000000..5f76f8b --- /dev/null +++ b/v0.7.4/rect2.html @@ -0,0 +1,1422 @@ + + + + + + + + + + + + + + + + + +Module rect2 + + + + + + + + +
+
+

Module rect2

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initRect2(pos, size: Vector2): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initRect2(x, y, sizeX, sizeY: float32): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Rect2): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc area(self: Rect2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc intersects(a, b: Rect2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc encloses(a, b: Rect2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hasNoArea(self: Rect2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc clip(self, b: Rect2): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc merge(self, b: Rect2): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc contains(self: Rect2; point: Vector2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc grow(self: Rect2; by: float32): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc expand(self: Rect2; to: Vector2): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: Rect2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:42 UTC +
+
+
+
+ + + diff --git a/v0.7.4/rids.html b/v0.7.4/rids.html new file mode 100644 index 0000000..b6f49c1 --- /dev/null +++ b/v0.7.4/rids.html @@ -0,0 +1,1345 @@ + + + + + + + + + + + + + + + + + +Module rids + + + + + + + + +
+
+

Module rids

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initRID(): RID {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initRID(obj: ptr GodotObject): RID {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc id(self: RID): uint32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: RID): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: RID): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(a, b: RID): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:43 UTC +
+
+
+
+ + + diff --git a/v0.7.4/transform2d.html b/v0.7.4/transform2d.html new file mode 100644 index 0000000..ac3886d --- /dev/null +++ b/v0.7.4/transform2d.html @@ -0,0 +1,1540 @@ + + + + + + + + + + + + + + + + + +Module transform2d + + + + + + + + +
+
+

Module transform2d

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initTransform2D(): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initTransform2D(rot: float32; pos: Vector2): Transform2D {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc initTransform2D(xAxis, yAxis, origin: Vector2): Transform2D {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Transform2D): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc inverse(self: Transform2D): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc affineInverse(self: Transform2D): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotation(self: Transform2D): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc origin(self: Transform2D): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc scale(self: Transform2D): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc orthonormalized(self: Transform2D): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotated(self: Transform2D; phi: float32): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc scaled(self: Transform2D; scale: Vector2): Transform2D {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc translated(self: Transform2D; offset: Vector2): Transform2D {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc xformVector2(self: Transform2D; v: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformInvVector2(self: Transform2D; v: Vector2): Vector2 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc basisXformVector2(self: Transform2D; v: Vector2): Vector2 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc basisXformInvVector2(self: Transform2D; v: Vector2): Vector2 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc xformRect2(self: Transform2D; rect: Rect2): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformInvRect2(self: Transform2D; rect: Rect2): Rect2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc interpolateWith(self, m: Transform2D; c: float32): Transform2D {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: Transform2D): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(a, b: Transform2D): Transform2D {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(a: var Transform2D; b: Transform2D) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:43 UTC +
+
+
+
+ + + diff --git a/v0.7.4/transforms.html b/v0.7.4/transforms.html new file mode 100644 index 0000000..22a93f6 --- /dev/null +++ b/v0.7.4/transforms.html @@ -0,0 +1,1504 @@ + + + + + + + + + + + + + + + + + +Module transforms + + + + + + + + +
+
+

Module transforms

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc initTransform(): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initTransform(xAxis, yAxis, zAxis, origin: Vector3): Transform {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc initTransform(basis: Basis; origin: Vector3): Transform {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Transform): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc inverse(self: Transform): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc affineInverse(self: Transform): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc orthonormalized(self: Transform): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotated(self: Transform; axis: Vector3; phi: float32): Transform {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc scaled(self: Transform; scale: Vector3): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc translated(self: Transform; offset: Vector3): Transform {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc lookingAt(self: Transform; target, up: Vector3): Transform {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc xformPlane(self: Transform; plane: Plane): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformInvPlane(self: Transform; plane: Plane): Plane {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformVector3(self: Transform; v: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformInvVector3(self: Transform; v: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformAABB(self: Transform; rect: AABB): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc xformInvAABB(self: Transform; rect: AABB): AABB {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self: Transform; b: Transform): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(self, other: Transform): Transform {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(self: var Transform; other: Transform) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:43 UTC +
+
+
+
+ + + diff --git a/v0.7.4/variants.html b/v0.7.4/variants.html new file mode 100644 index 0000000..c302ec8 --- /dev/null +++ b/v0.7.4/variants.html @@ -0,0 +1,2127 @@ + + + + + + + + + + + + + + + + + +Module variants + + + + + + + + +
+
+

Module variants

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Types

+
+
Variant = ref object
+  godotVariant: GodotVariant
+  noDeinit: bool
+
+
+ +  Source +Edit + +
+ +
+
+

Procs

+
+
proc markNoDeinit(v: Variant) {.
inline, raises: [], tags: []
.}
+
+Makes it so that internal GodotVariant object will not be destroyed when the reference is gone. Use only if you know what you are doing. +  Source +Edit + +
+
proc godotVariant(v: Variant): ptr GodotVariant {.
inline, raises: [], tags: []
.}
+
+WARNING: do not keep the returned value for longer than the lifetime of v +  Source +Edit + +
+
proc getType(v: Variant): VariantType {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc variantFinalizer(v: Variant) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Variant): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(v: Variant): Variant {.
inline, raises: [], tags: []
.}
+
+Makes a copy +  Source +Edit + +
+
proc newVariant(v: GodotVariant): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(b: bool): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149125: uint8): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149148: uint16): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149171: uint32): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149194: uint64): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149217: uint): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149240: int8): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149263: int16): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149286: int32): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149309: int64): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(i149332: int): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(r: cdouble): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(s: string): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(v2: Vector2): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(rect2: Rect2): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(v3: Vector3): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(t2d: Transform2D): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(plane: Plane): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(quat: Quat): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(aabb: AABB): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(basis: Basis): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(trans: Transform): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(color: Color): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(nodePath: NodePath): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(godotNodePath: GodotNodePath): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(rid: RID): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(obj: ptr GodotObject): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(arr: Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(pba: PoolByteArray): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(pia: PoolIntArray): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(pra: PoolRealArray): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(psa: PoolStringArray): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(pv2a: PoolVector2Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(pv3a: PoolVector3Array): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc newVariant(pca: PoolColorArray): Variant {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asBool(self: Variant): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asUInt(self: Variant): uint64 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asInt(self: Variant): int64 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asReal(self: Variant): cdouble {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asString(self: Variant): string {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asVector2(self: Variant): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asRect2(self: Variant): Rect2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asVector3(self: Variant): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asTransform2D(self: Variant): Transform2D {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asPlane(self: Variant): Plane {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asQuat(self: Variant): Quat {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asAABB(self: Variant): AABB {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asBasis(self: Variant): Basis {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asTransform(self: Variant): Transform {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asColor(self: Variant): Color {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asNodePath(self: Variant): NodePath {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asRID(self: Variant): RID {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asGodotObject(self: Variant): ptr GodotObject {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asArray(self: Variant): Array {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc asPoolByteArray(self: Variant): PoolByteArray {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc asPoolIntArray(self: Variant): PoolIntArray {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc asPoolRealArray(self: Variant): PoolRealArray {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc asPoolStringArray(self: Variant): PoolStringArray {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc asPoolVector2Array(self: Variant): PoolVector2Array {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc asPoolVector3Array(self: Variant): PoolVector3Array {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc asPoolColorArray(self: Variant): PoolColorArray {.
raises: [Exception],
+    tags: [RootEffect]
.}
+
+ +  Source +Edit + +
+
proc hasMethod(self: Variant; meth: string): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self, other: Variant): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(self, other: Variant): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc hashCompare(self, other: Variant): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc booleanize(self: Variant): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:44 UTC +
+
+
+
+ + + diff --git a/v0.7.4/vector2.html b/v0.7.4/vector2.html new file mode 100644 index 0000000..690ff86 --- /dev/null +++ b/v0.7.4/vector2.html @@ -0,0 +1,1720 @@ + + + + + + + + + + + + + + + + + +Module vector2 + + + + + + + + +
+
+

Module vector2

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc vec2(): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc vec2(x, y: float32): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Vector2): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc normalized(self: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc length(self: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc angle(self: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc lengthSquared(self: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isNormalized(self: Vector2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc distanceTo(self, to: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc distanceSquaredTo(self, to: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc angleTo(self, to: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc angleToPoint(self, to: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc lerp(self, b: Vector2; t: float32): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc cubicInterpolate(self, b, preA, postB: Vector2; t: float32): Vector2 {.
inline,
+    raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc rotated(self: Vector2; phi: float32): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc tangent(self: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc floor(self: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc snapped(self: Vector2; by: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc aspect(self: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc dot(a, b: Vector2): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc slide(self, n: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc bounce(self, n: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reflect(self, n: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc abs(self: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc clamped(self: Vector2; length: float32): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+`(self, other: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+=`(self: var Vector2; other: Vector2) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(self, other: Vector2): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-=`(self: var Vector2; other: Vector2) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(self, other: Vector2): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(self: var Vector2; other: Vector2) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(self: Vector2; scalar: float32): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(self: var Vector2; scalar: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/`(self, other: Vector2): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/=`(self: var Vector2; other: Vector2) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/`(self: Vector2; scalar: float32): Vector2 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/=`(self: var Vector2; scalar: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(self, other: Vector2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(self, other: Vector2): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(self: Vector2): Vector2 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:44 UTC +
+
+
+
+ + + diff --git a/v0.7.4/vector3.html b/v0.7.4/vector3.html new file mode 100644 index 0000000..31d6cf8 --- /dev/null +++ b/v0.7.4/vector3.html @@ -0,0 +1,1799 @@ + + + + + + + + + + + + + + + + + +Module vector3 + + + + + + + + +
+
+

Module vector3

+
+
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+

+ +
+

Procs

+
+
proc vec3(): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc vec3(x, y, z: float32): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `$`(self: Vector3): string {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+`(a, b: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `+=`(a: var Vector3; b: Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(a, b: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-=`(a: var Vector3; b: Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(a, b: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(a: var Vector3; b: Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(a: Vector3; b: float32): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*`(b: float32; a: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `*=`(a: var Vector3; b: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/`(a, b: Vector3): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/=`(a: var Vector3; b: Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/`(a: Vector3; b: float32): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `/=`(a: var Vector3; b: float32) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `==`(a, b: Vector3): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `<`(a, b: Vector3): bool {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `-`(self: Vector3): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: Vector3; idx: range[0 .. 2]): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]`(self: var Vector3; idx: range[0 .. 2]): var float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc `[]=`(self: var Vector3; idx: range[0 .. 2]; val: float32) {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc minAxis(self: Vector3): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc maxAxis(self: Vector3): int {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc length(self: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc lengthSquared(self: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc normalize(self: var Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc normalized(self: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc isNormalized(self: Vector3): bool {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc zero(self: var Vector3) {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc inverse(self: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc cross(self, other: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc dot(self, other: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc abs(self: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc sign(self: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc floor(self: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc ceil(self: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc lerp(self: Vector3; other: Vector3; t: float32): Vector3 {.
inline, raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+
proc distanceTo(self, other: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc distanceSquaredTo(self, other: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc angleTo(self, other: Vector3): float32 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc slide(self, n: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc reflect(self, n: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc bounce(self, n: Vector3): Vector3 {.
inline, raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc snap(self: var Vector3; other: Vector3) {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc snapped(self: Vector3; other: Vector3): Vector3 {.
raises: [], tags: []
.}
+
+ +  Source +Edit + +
+
proc cubicInterpolate(self, b, preA, postB: Vector3; t: float32): Vector3 {.
raises: [],
+    tags: []
.}
+
+ +  Source +Edit + +
+ +
+ +
+
+ +
+
+ +
+ Made with Nim. Generated: 2018-01-25 12:58:45 UTC +
+
+
+
+ + +