From dfa3e2199f94e7003b9fdefcc5a7805c5cafe405 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <guzba8@gmail.com>
Date: Sun, 29 Nov 2020 18:55:54 -0600
Subject: [PATCH 1/6] vec2
---
src/vmath.nim | 72 ++++++++++++++++++++++++++-------------------------
1 file changed, 37 insertions(+), 35 deletions(-)
diff --git a/src/vmath.nim b/src/vmath.nim
index ed57e32..dafa4b6 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -21,6 +21,31 @@ proc lerp*(a: float32, b: float32, v: float32): float32 =
## * 0.5 -> between a and b
a * (1.0 - v) + b * v
+proc fixAngle*(angle: float32): float32 =
+ ## Make angle be from -PI to PI radians.
+ var angle = angle
+ while angle > PI:
+ angle -= PI * 2
+ while angle < -PI:
+ angle += PI * 2
+ angle
+
+proc angleBetween*(a, b: float32): float32 =
+ ## Angle between angle a and angle b.
+ fixAngle(b - a)
+
+proc turnAngle*(a, b, speed: float32): float32 =
+ ## Move from angle a to angle b with step of v.
+ var
+ turn = fixAngle(b - a)
+ if abs(turn) < speed:
+ return b
+ elif turn > speed:
+ turn = speed
+ elif turn < -speed:
+ turn = -speed
+ a + turn
+
type Vec2* = object
## 2D vector
x*: float32
@@ -81,7 +106,7 @@ proc `-`*(a: Vec2): Vec2 {.inline.} =
result.x = -a.x
result.y = -a.y
-proc hash*(a: Vec2): Hash =
+proc hash*(a: Vec2): Hash {.inline.} =
hash((a.x, a.y))
proc lengthSq*(a: Vec2): float32 {.inline.} =
@@ -97,7 +122,7 @@ proc normalize*(a: Vec2): Vec2 {.inline.} =
a / a.length
proc dot*(a: Vec2, b: Vec2): float32 {.inline.} =
- a.x*b.x + a.y*b.y
+ a.x * b.x + a.y * b.y
proc dir*(at: Vec2, to: Vec2): Vec2 {.inline.} =
(at - to).normalize()
@@ -127,36 +152,29 @@ proc inRect*(v: Vec2, a: Vec2, b: Vec2): bool {.inline.} =
v.x > min.x and v.x < max.x and v.y > min.y and v.y < max.y
proc `[]`*(a: Vec2, i: int): float32 =
- assert(i == 0 or i == 1)
+ if i > 1:
+ raise newException(IndexDefect, "Vec2 index out of bounds")
if i == 0:
- return a.x
- elif i == 1:
- return a.y
+ a.x
+ else:
+ a.y
proc `[]=`*(a: var Vec2, i: int, b: float32) =
- assert(i == 0 or i == 1)
+ if i > 1:
+ raise newException(IndexDefect, "Vec2 index out of bounds")
if i == 0:
a.x = b
- elif i == 1:
+ else:
a.y = b
proc randVec2*(): Vec2 =
- let a = rand(PI*2)
+ let a = rand(PI * 2)
let v = rand(1.0)
- vec2(cos(a)*v, sin(a)*v)
+ vec2(cos(a) * v, sin(a) * v)
proc `$`*(a: Vec2): string =
&"({a.x:.4f}, {a.y:.4f})"
-proc fixAngle*(angle: float32): float32 =
- ## Make angle be from -PI to PI radians.
- var angle = angle
- while angle > PI:
- angle -= PI*2
- while angle < -PI:
- angle += PI*2
- angle
-
proc angle*(a: Vec2): float32 =
## Angle of a Vec2.
arctan2(a.y, a.x)
@@ -165,22 +183,6 @@ proc angleBetween*(a: Vec2, b: Vec2): float32 =
## Angle between 2 Vec2.
fixAngle(arctan2(a.y - b.y, a.x - b.x))
-proc angleBetween*(a, b: float32): float32 =
- ## Angle between angle a and angle b.
- (b - a).fixAngle
-
-proc turnAngle*(a, b, speed: float32): float32 =
- ## Move from angle a to angle b with step of v.
- var
- turn = fixAngle(b - a)
- if abs(turn) < speed:
- return b
- elif turn > speed:
- turn = speed
- elif turn < -speed:
- turn = -speed
- a + turn
-
type Vec3* = object
## 3D vector
x*: float32
From 80a2b4dadeb7d77635926402ce3ea8c8a4cecbf6 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <guzba8@gmail.com>
Date: Sun, 29 Nov 2020 18:58:47 -0600
Subject: [PATCH 2/6] rand param
---
src/vmath.nim | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/vmath.nim b/src/vmath.nim
index dafa4b6..9b2cf28 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -167,9 +167,9 @@ proc `[]=`*(a: var Vec2, i: int, b: float32) =
else:
a.y = b
-proc randVec2*(): Vec2 =
- let a = rand(PI * 2)
- let v = rand(1.0)
+proc randVec2*(r: var Rand): Vec2 =
+ let a = r.rand(PI * 2)
+ let v = r.rand(1.0)
vec2(cos(a) * v, sin(a) * v)
proc `$`*(a: Vec2): string =
@@ -368,12 +368,12 @@ proc almostEquals*(a, b: Vec3, precision = 1e-6): bool =
let c = a - b
abs(c.x) < precision and abs(c.y) < precision and abs(c.z) < precision
-proc randVec3*(): Vec3 =
+proc randVec3*(r: var Rand): Vec3 =
## Generates a random unit vector based on
## http://mathworld.wolfram.com/SpherePointPicking.html
let
- u = rand(0.0 .. 1.0)
- v = rand(0.0 .. 1.0)
+ u = r.rand(0.0 .. 1.0)
+ v = r.rand(0.0 .. 1.0)
th = 2 * PI * u
ph = arccos(2 * v - 1)
vec3(
From 1a5fbe202a0eea57b1f143132696115a8962bf3a Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <guzba8@gmail.com>
Date: Sun, 29 Nov 2020 19:21:58 -0600
Subject: [PATCH 3/6] mostly inlines + rand
---
src/vmath.nim | 157 +++++++++++++++++++++++++-------------------------
1 file changed, 80 insertions(+), 77 deletions(-)
diff --git a/src/vmath.nim b/src/vmath.nim
index 9b2cf28..dbb8a1c 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -2,19 +2,19 @@ import hashes, math, random, strformat, strutils
export math
-proc between*(value, min, max: float32): bool =
+proc between*(value, min, max: float32): bool {.inline.} =
## Returns true if value is between min and max or equal to them.
(value >= min) and (value <= max)
-proc sign*(v: float32): float32 =
+proc sign*(v: float32): float32 {.inline.} =
## Returns the sign of a number, -1 or 1.
if v >= 0: 1.0 else: -1.0
-proc quantize*(v: float32, n: float32): float32 =
+proc quantize*(v: float32, n: float32): float32 {.inline.} =
## Makes v be multipe of n. Rounding to integer quantize by 1.0.
sign(v) * floor(abs(v) / n) * n
-proc lerp*(a: float32, b: float32, v: float32): float32 =
+proc lerp*(a: float32, b: float32, v: float32): float32 {.inline.} =
## Interpolates value between a and b.
## * 0 -> a
## * 1 -> b
@@ -189,17 +189,17 @@ type Vec3* = object
y*: float32
z*: float32
-proc vec3*(x, y, z: float32): Vec3 =
+proc vec3*(x, y, z: float32): Vec3 {.inline.} =
result.x = x
result.y = y
result.z = z
-proc vec3*(v: float32): Vec3 =
+proc vec3*(v: float32): Vec3 {.inline.} =
result.x = v
result.y = v
result.z = v
-proc vec3*(a: Vec3): Vec3 =
+proc vec3*(a: Vec3): Vec3 {.inline.} =
result.x = a.x
result.y = a.y
result.z = a.z
@@ -208,103 +208,103 @@ const X_DIR* = vec3(1.0, 0.0, 0.0)
const Y_DIR* = vec3(0.0, 1.0, 0.0)
const Z_DIR* = vec3(0.0, 0.0, 1.0)
-proc `+`*(a: Vec3, b: Vec3): Vec3 =
+proc `+`*(a: Vec3, b: Vec3): Vec3 {.inline.} =
result.x = a.x + b.x
result.y = a.y + b.y
result.z = a.z + b.z
-proc `-`*(a: Vec3, b: Vec3): Vec3 =
+proc `-`*(a: Vec3, b: Vec3): Vec3 {.inline.} =
result.x = a.x - b.x
result.y = a.y - b.y
result.z = a.z - b.z
-proc `-`*(a: Vec3): Vec3 =
+proc `-`*(a: Vec3): Vec3 {.inline.} =
result.x = -a.x
result.y = -a.y
result.z = -a.z
-proc `*`*(a: Vec3, b: float32): Vec3 =
+proc `*`*(a: Vec3, b: float32): Vec3 {.inline.} =
result.x = a.x * b
result.y = a.y * b
result.z = a.z * b
-proc `*`*(a: float32, b: Vec3): Vec3 =
+proc `*`*(a: float32, b: Vec3): Vec3 {.inline.} =
b * a
-proc `/`*(a: Vec3, b: float32): Vec3 =
+proc `/`*(a: Vec3, b: float32): Vec3 {.inline.} =
result.x = a.x / b
result.y = a.y / b
result.z = a.z / b
-proc `/`*(a: float32, b: Vec3): Vec3 =
+proc `/`*(a: float32, b: Vec3): Vec3 {.inline.} =
result.x = a / b.x
result.y = a / b.y
result.z = a / b.z
-proc `+=`*(a: var Vec3, b: Vec3) =
+proc `+=`*(a: var Vec3, b: Vec3) {.inline.} =
a.x += b.x
a.y += b.y
a.z += b.z
-proc `-=`*(a: var Vec3, b: Vec3) =
+proc `-=`*(a: var Vec3, b: Vec3) {.inline.} =
a.x -= b.x
a.y -= b.y
a.z -= b.z
-proc `*=`*(a: var Vec3, b: float32) =
+proc `*=`*(a: var Vec3, b: float32) {.inline.} =
a.x *= b
a.y *= b
a.z *= b
-proc `/=`*(a: var Vec3, b: float32) =
+proc `/=`*(a: var Vec3, b: float32) {.inline.} =
a.x /= b
a.y /= b
a.z /= b
-proc zero*(a: var Vec3) =
+proc zero*(a: var Vec3) {.inline.} =
a.x = 0
a.y = 0
a.z = 0
-proc `-`*(a: var Vec3): Vec3 =
+proc `-`*(a: var Vec3): Vec3 {.inline.} =
result.x = -a.x
result.y = -a.y
result.z = -a.z
-proc hash*(a: Vec3): Hash =
+proc hash*(a: Vec3): Hash {.inline.} =
hash((a.x, a.y, a.z))
-proc lengthSq*(a: Vec3): float32 =
+proc lengthSq*(a: Vec3): float32 {.inline.} =
a.x * a.x + a.y * a.y + a.z * a.z
-proc length*(a: Vec3): float32 =
+proc length*(a: Vec3): float32 {.inline.} =
sqrt(a.lengthSq)
-proc `length=`*(a: var Vec3, b: float32) =
+proc `length=`*(a: var Vec3, b: float32) {.inline.} =
a *= b / a.length
-proc floor*(a: Vec3): Vec3 =
+proc floor*(a: Vec3): Vec3 {.inline.} =
vec3(floor(a.x), floor(a.y), floor(a.z))
-proc round*(a: Vec3): Vec3 =
+proc round*(a: Vec3): Vec3 {.inline.} =
vec3(round(a.x), round(a.y), round(a.z))
-proc ceil*(a: Vec3): Vec3 =
+proc ceil*(a: Vec3): Vec3 {.inline.} =
vec3(ceil(a.x), ceil(a.y), ceil(a.z))
-proc normalize*(a: Vec3): Vec3 =
- a / sqrt(a.x*a.x + a.y*a.y + a.z*a.z)
+proc normalize*(a: Vec3): Vec3 {.inline.} =
+ a / sqrt(a.x * a.x + a.y * a.y + a.z * a.z)
-proc cross*(a: Vec3, b: Vec3): Vec3 =
- result.x = a.y*b.z - a.z*b.y
- result.y = a.z*b.x - a.x*b.z
- result.z = a.x*b.y - a.y*b.x
+proc cross*(a: Vec3, b: Vec3): Vec3 {.inline.} =
+ result.x = a.y * b.z - a.z * b.y
+ result.y = a.z * b.x - a.x * b.z
+ result.z = a.x * b.y - a.y * b.x
proc computeNormal*(a, b, c: Vec3): Vec3 =
cross(c - b, b - a).normalize()
-proc dot*(a: Vec3, b: Vec3): float32 =
- a.x*b.x + a.y*b.y + a.z*b.z
+proc dot*(a: Vec3, b: Vec3): float32 {.inline.} =
+ a.x * b.x + a.y * b.y + a.z * b.z
proc dir*(at: Vec3, to: Vec3): Vec3 =
(at - to).normalize()
@@ -329,42 +329,44 @@ proc angleBetween*(a, b: Vec3): float32 =
arccos(dot)
proc `[]`*(a: Vec3, i: int): float32 =
- assert(i == 0 or i == 1 or i == 2)
+ if i > 2:
+ raise newException(IndexDefect, "Vec3 index out of bounds")
if i == 0:
- return a.x
+ a.x
elif i == 1:
- return a.y
- elif i == 2:
- return a.z
+ a.y
+ else:
+ a.z
proc `[]=`*(a: var Vec3, i: int, b: float32) =
- assert(i == 0 or i == 1 or i == 2)
+ if i > 2:
+ raise newException(IndexDefect, "Vec3 index out of bounds")
if i == 0:
a.x = b
elif i == 1:
a.y = b
- elif i == 2:
+ else:
a.z = b
-proc xy*(a: Vec3): Vec2 =
+proc xy*(a: Vec3): Vec2 {.inline.} =
vec2(a.x, a.y)
-proc xz*(a: Vec3): Vec2 =
+proc xz*(a: Vec3): Vec2 {.inline.} =
vec2(a.x, a.z)
-proc yx*(a: Vec3): Vec2 =
+proc yx*(a: Vec3): Vec2 {.inline.} =
vec2(a.y, a.x)
-proc yz*(a: Vec3): Vec2 =
+proc yz*(a: Vec3): Vec2 {.inline.} =
vec2(a.y, a.z)
-proc zx*(a: Vec3): Vec2 =
+proc zx*(a: Vec3): Vec2 {.inline.} =
vec2(a.y, a.x)
-proc zy*(a: Vec3): Vec2 =
+proc zy*(a: Vec3): Vec2 {.inline.} =
vec2(a.z, a.y)
-proc almostEquals*(a, b: Vec3, precision = 1e-6): bool =
+proc almostEquals*(a, b: Vec3, precision = 1e-6): bool {.inline.} =
let c = a - b
abs(c.x) < precision and abs(c.y) < precision and abs(c.z) < precision
@@ -392,129 +394,130 @@ type Vec4* = object
z*: float32
w*: float32
-proc vec4*(x, y, z, w: float32): Vec4 =
+proc vec4*(x, y, z, w: float32): Vec4 {.inline.} =
result.x = x
result.y = y
result.z = z
result.w = w
-proc vec4*(v: float32): Vec4 =
+proc vec4*(v: float32): Vec4 {.inline.} =
result.x = v
result.y = v
result.z = v
result.w = v
-proc `+`*(a: Vec4, b: Vec4): Vec4 =
+proc `+`*(a: Vec4, b: Vec4): Vec4 {.inline.} =
result.x = a.x + b.x
result.y = a.y + b.y
result.z = a.z + b.z
result.w = a.w + b.w
-proc `-`*(a: Vec4, b: Vec4): Vec4 =
+proc `-`*(a: Vec4, b: Vec4): Vec4 {.inline.} =
result.x = a.x - b.x
result.y = a.y - b.y
result.z = a.z - b.z
result.w = a.w - b.w
-proc `-`*(a: Vec4): Vec4 =
+proc `-`*(a: Vec4): Vec4 {.inline.} =
result.x = -a.x
result.y = -a.y
result.z = -a.z
result.w = -a.w
-proc `*`*(a: Vec4, b: float32): Vec4 =
+proc `*`*(a: Vec4, b: float32): Vec4 {.inline.} =
result.x = a.x * b
result.y = a.y * b
result.z = a.z * b
result.w = a.w * b
-proc `*`*(a: float32, b: Vec4): Vec4 =
+proc `*`*(a: float32, b: Vec4): Vec4 {.inline.} =
b * a
-proc `/`*(a: Vec4, b: float32): Vec4 =
+proc `/`*(a: Vec4, b: float32): Vec4 {.inline.} =
result.x = a.x / b
result.y = a.y / b
-
result.z = a.z / b
result.w = a.w / b
-proc `/`*(a: float32, b: Vec4): Vec4 =
+proc `/`*(a: float32, b: Vec4): Vec4 {.inline.}=
result.x = a / b.x
result.y = a / b.y
result.z = a / b.z
result.w = a / b.w
-proc `+=`*(a: var Vec4, b: Vec4) =
+proc `+=`*(a: var Vec4, b: Vec4) {.inline.} =
a.x += b.x
a.y += b.y
a.z += b.z
a.w += b.w
-proc `-=`*(a: var Vec4, b: Vec4) =
+proc `-=`*(a: var Vec4, b: Vec4) {.inline.} =
a.x -= b.x
a.y -= b.y
a.z -= b.z
a.w -= b.w
-proc `*=`*(a: var Vec4, b: float32) =
+proc `*=`*(a: var Vec4, b: float32) {.inline.} =
a.x *= b
a.y *= b
a.z *= b
a.w *= b
-proc `/=`*(a: var Vec4, b: float32) =
+proc `/=`*(a: var Vec4, b: float32) {.inline.} =
a.x /= b
a.y /= b
a.z /= b
a.w /= b
-proc zero*(a: var Vec4) =
+proc zero*(a: var Vec4) {.inline.} =
a.x = 0
a.y = 0
a.z = 0
a.w = 0
-proc hash*(a: Vec4): Hash =
+proc hash*(a: Vec4): Hash {.inline.} =
hash((a.x, a.y, a.z, a.w))
proc `[]`*(a: Vec4, i: int): float32 =
- assert(i == 0 or i == 1 or i == 2)
+ if i > 3:
+ raise newException(IndexDefect, "Vec4 index out of bounds")
if i == 0:
- return a.x
+ a.x
elif i == 1:
- return a.y
+ a.y
elif i == 2:
- return a.z
- elif i == 3:
- return a.w
+ a.z
+ else:
+ a.w
proc `[]=`*(a: var Vec4, i: int, b: float32) =
- assert(i == 0 or i == 1 or i == 2)
+ if i > 3:
+ raise newException(IndexDefect, "Vec4 index out of bounds")
if i == 0:
a.x = b
elif i == 1:
a.y = b
elif i == 2:
a.z = b
- elif i == 3:
+ else:
a.w = b
proc lerp*(a: Vec4, b: Vec4, v: float32): Vec4 =
a * (1.0 - v) + b * v
-proc xyz*(a: Vec4): Vec3 =
+proc xyz*(a: Vec4): Vec3 {.inline.} =
vec3(a.x, a.y, a.z)
proc `$`*(a: Vec4): string =
&"({a.x:.8f}, {a.y:.8f}, {a.z:.8f}, {a.w:.8f})"
-proc vec3*(a: Vec2, z = 0.0): Vec3 =
+proc vec3*(a: Vec2, z = 0.0): Vec3 {.inline.} =
vec3(a.x, a.y, z)
-proc vec4*(a: Vec3, w = 0.0): Vec4 =
+proc vec4*(a: Vec3, w = 0.0): Vec4 {.inline.} =
vec4(a.x, a.y, a.z, w)
-proc vec4*(a: Vec2, z = 0.0, w = 0.0): Vec4 =
+proc vec4*(a: Vec2, z = 0.0, w = 0.0): Vec4 {.inline.} =
vec4(a.x, a.y, z, w)
type Mat3* = array[9, float32] ## 3x3 Matrix
From 35c99e641f0b9b5c66a5bc838c30637cc4fd50e5 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <guzba8@gmail.com>
Date: Sun, 29 Nov 2020 22:10:43 -0600
Subject: [PATCH 4/6] fix
---
src/vmath.nim | 31 ++++++++++++++++++++++++-------
1 file changed, 24 insertions(+), 7 deletions(-)
diff --git a/src/vmath.nim b/src/vmath.nim
index dbb8a1c..8890069 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -152,7 +152,7 @@ proc inRect*(v: Vec2, a: Vec2, b: Vec2): bool {.inline.} =
v.x > min.x and v.x < max.x and v.y > min.y and v.y < max.y
proc `[]`*(a: Vec2, i: int): float32 =
- if i > 1:
+ if i < 0 or i > 1:
raise newException(IndexDefect, "Vec2 index out of bounds")
if i == 0:
a.x
@@ -160,7 +160,7 @@ proc `[]`*(a: Vec2, i: int): float32 =
a.y
proc `[]=`*(a: var Vec2, i: int, b: float32) =
- if i > 1:
+ if i < 0 or i > 1:
raise newException(IndexDefect, "Vec2 index out of bounds")
if i == 0:
a.x = b
@@ -329,7 +329,7 @@ proc angleBetween*(a, b: Vec3): float32 =
arccos(dot)
proc `[]`*(a: Vec3, i: int): float32 =
- if i > 2:
+ if i < 0 or i > 2:
raise newException(IndexDefect, "Vec3 index out of bounds")
if i == 0:
a.x
@@ -339,7 +339,7 @@ proc `[]`*(a: Vec3, i: int): float32 =
a.z
proc `[]=`*(a: var Vec3, i: int, b: float32) =
- if i > 2:
+ if i < 0 or i > 2:
raise newException(IndexDefect, "Vec3 index out of bounds")
if i == 0:
a.x = b
@@ -479,7 +479,7 @@ proc hash*(a: Vec4): Hash {.inline.} =
hash((a.x, a.y, a.z, a.w))
proc `[]`*(a: Vec4, i: int): float32 =
- if i > 3:
+ if i < 0 or i > 3:
raise newException(IndexDefect, "Vec4 index out of bounds")
if i == 0:
a.x
@@ -491,7 +491,7 @@ proc `[]`*(a: Vec4, i: int): float32 =
a.w
proc `[]=`*(a: var Vec4, i: int, b: float32) =
- if i > 3:
+ if i < 0 or i > 3:
raise newException(IndexDefect, "Vec4 index out of bounds")
if i == 0:
a.x = b
@@ -520,6 +520,23 @@ proc vec4*(a: Vec3, w = 0.0): Vec4 {.inline.} =
proc vec4*(a: Vec2, z = 0.0, w = 0.0): Vec4 {.inline.} =
vec4(a.x, a.y, z, w)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
type Mat3* = array[9, float32] ## 3x3 Matrix
template `[]`*(a: Mat3, i, j: int): float32 = a[i * 3 + j]
@@ -550,7 +567,7 @@ proc identity*(a: var Mat3) =
a[7] = 0
a[8] = 1
-proc mat3*(): Mat3 =
+proc mat3*(): Mat3 {.inline.} =
result.identity()
proc transpose*(a: Mat3): Mat3 =
From 2ddcdc4dc60f3e0341cee41d2c9b6365d7298e2b Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <guzba8@gmail.com>
Date: Sun, 29 Nov 2020 22:23:00 -0600
Subject: [PATCH 5/6] better
---
src/vmath.nim | 78 ++++++++++++++++++++-------------------------------
1 file changed, 30 insertions(+), 48 deletions(-)
diff --git a/src/vmath.nim b/src/vmath.nim
index 8890069..2969b9c 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -152,20 +152,16 @@ proc inRect*(v: Vec2, a: Vec2, b: Vec2): bool {.inline.} =
v.x > min.x and v.x < max.x and v.y > min.y and v.y < max.y
proc `[]`*(a: Vec2, i: int): float32 =
- if i < 0 or i > 1:
- raise newException(IndexDefect, "Vec2 index out of bounds")
- if i == 0:
- a.x
- else:
- a.y
+ case i
+ of 0: a.x
+ of 1: a.y
+ else: raise newException(IndexDefect, "Index not in 0 .. 1")
proc `[]=`*(a: var Vec2, i: int, b: float32) =
- if i < 0 or i > 1:
- raise newException(IndexDefect, "Vec2 index out of bounds")
- if i == 0:
- a.x = b
- else:
- a.y = b
+ case i
+ of 0: a.x = b
+ of 1: a.y = b
+ else: raise newException(IndexDefect, "Index not in 0 .. 1")
proc randVec2*(r: var Rand): Vec2 =
let a = r.rand(PI * 2)
@@ -329,24 +325,18 @@ proc angleBetween*(a, b: Vec3): float32 =
arccos(dot)
proc `[]`*(a: Vec3, i: int): float32 =
- if i < 0 or i > 2:
- raise newException(IndexDefect, "Vec3 index out of bounds")
- if i == 0:
- a.x
- elif i == 1:
- a.y
- else:
- a.z
+ case i
+ of 0: a.x
+ of 1: a.y
+ of 2: a.z
+ else: raise newException(IndexDefect, "Index not in 0 .. 2")
proc `[]=`*(a: var Vec3, i: int, b: float32) =
- if i < 0 or i > 2:
- raise newException(IndexDefect, "Vec3 index out of bounds")
- if i == 0:
- a.x = b
- elif i == 1:
- a.y = b
- else:
- a.z = b
+ case i
+ of 0: a.x = b
+ of 1: a.y = b
+ of 2: a.z = b
+ else: raise newException(IndexDefect, "Index not in 0 .. 2")
proc xy*(a: Vec3): Vec2 {.inline.} =
vec2(a.x, a.y)
@@ -479,28 +469,20 @@ proc hash*(a: Vec4): Hash {.inline.} =
hash((a.x, a.y, a.z, a.w))
proc `[]`*(a: Vec4, i: int): float32 =
- if i < 0 or i > 3:
- raise newException(IndexDefect, "Vec4 index out of bounds")
- if i == 0:
- a.x
- elif i == 1:
- a.y
- elif i == 2:
- a.z
- else:
- a.w
+ case i
+ of 0: a.x
+ of 1: a.y
+ of 2: a.z
+ of 3: a.w
+ else: raise newException(IndexDefect, "Index not in 0 .. 3")
proc `[]=`*(a: var Vec4, i: int, b: float32) =
- if i < 0 or i > 3:
- raise newException(IndexDefect, "Vec4 index out of bounds")
- if i == 0:
- a.x = b
- elif i == 1:
- a.y = b
- elif i == 2:
- a.z = b
- else:
- a.w = b
+ case i
+ of 0: a.x = b
+ of 1: a.y = b
+ of 2: a.z = b
+ of 3: a.w = b
+ else: raise newException(IndexDefect, "Index not in 0 .. 3")
proc lerp*(a: Vec4, b: Vec4, v: float32): Vec4 =
a * (1.0 - v) + b * v
From 21a4ac8ebfbf1c64dd2ce18438529198e0cc88e2 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <guzba8@gmail.com>
Date: Sun, 29 Nov 2020 22:29:21 -0600
Subject: [PATCH 6/6] inline more
---
src/vmath.nim | 33 ++++++++-------------------------
1 file changed, 8 insertions(+), 25 deletions(-)
diff --git a/src/vmath.nim b/src/vmath.nim
index 2969b9c..9a11ee6 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -30,7 +30,7 @@ proc fixAngle*(angle: float32): float32 =
angle += PI * 2
angle
-proc angleBetween*(a, b: float32): float32 =
+proc angleBetween*(a, b: float32): float32 {.inline.} =
## Angle between angle a and angle b.
fixAngle(b - a)
@@ -171,11 +171,11 @@ proc randVec2*(r: var Rand): Vec2 =
proc `$`*(a: Vec2): string =
&"({a.x:.4f}, {a.y:.4f})"
-proc angle*(a: Vec2): float32 =
+proc angle*(a: Vec2): float32 {.inline.} =
## Angle of a Vec2.
arctan2(a.y, a.x)
-proc angleBetween*(a: Vec2, b: Vec2): float32 =
+proc angleBetween*(a: Vec2, b: Vec2): float32 {.inline.} =
## Angle between 2 Vec2.
fixAngle(arctan2(a.y - b.y, a.x - b.x))
@@ -302,16 +302,16 @@ proc computeNormal*(a, b, c: Vec3): Vec3 =
proc dot*(a: Vec3, b: Vec3): float32 {.inline.} =
a.x * b.x + a.y * b.y + a.z * b.z
-proc dir*(at: Vec3, to: Vec3): Vec3 =
+proc dir*(at: Vec3, to: Vec3): Vec3 {.inline.} =
(at - to).normalize()
-proc dist*(at: Vec3, to: Vec3): float32 =
+proc dist*(at: Vec3, to: Vec3): float32 {.inline.} =
(at - to).length
-proc distSq*(at: Vec3, to: Vec3): float32 =
+proc distSq*(at: Vec3, to: Vec3): float32 {.inline.} =
(at - to).lengthSq
-proc lerp*(a: Vec3, b: Vec3, v: float32): Vec3 =
+proc lerp*(a: Vec3, b: Vec3, v: float32): Vec3 {.inline.} =
a * (1.0 - v) + b * v
proc quantize*(v: Vec3, n: float32): Vec3 =
@@ -484,7 +484,7 @@ proc `[]=`*(a: var Vec4, i: int, b: float32) =
of 3: a.w = b
else: raise newException(IndexDefect, "Index not in 0 .. 3")
-proc lerp*(a: Vec4, b: Vec4, v: float32): Vec4 =
+proc lerp*(a: Vec4, b: Vec4, v: float32): Vec4 {.inline.} =
a * (1.0 - v) + b * v
proc xyz*(a: Vec4): Vec3 {.inline.} =
@@ -502,23 +502,6 @@ proc vec4*(a: Vec3, w = 0.0): Vec4 {.inline.} =
proc vec4*(a: Vec2, z = 0.0, w = 0.0): Vec4 {.inline.} =
vec4(a.x, a.y, z, w)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
type Mat3* = array[9, float32] ## 3x3 Matrix
template `[]`*(a: Mat3, i, j: int): float32 = a[i * 3 + j]