1 module raymathext; 2 3 import raylib; 4 import std.math; 5 6 pragma(inline, true): 7 8 version (unittest) 9 { 10 import fluent.asserts; 11 } 12 13 mixin template Linear() 14 { 15 import std.algorithm : canFind, map; 16 import std.range : join; 17 import std.traits : FieldNameTuple; 18 19 private static alias T = typeof(this); 20 21 static T zero() 22 { 23 enum fragment = [FieldNameTuple!T].map!(field => "0.").join(","); 24 return mixin("T(" ~ fragment ~ ")"); 25 } 26 27 static T one() 28 { 29 enum fragment = [FieldNameTuple!T].map!(field => "1.").join(","); 30 return mixin("T(" ~ fragment ~ ")"); 31 } 32 33 inout T opUnary(string op)() if (["+", "-"].canFind(op)) 34 { 35 enum fragment = [FieldNameTuple!T].map!(field => op ~ field).join(","); 36 return mixin("T(" ~ fragment ~ ")"); 37 } 38 39 static if (is(T == Rotor3)) 40 { 41 /// Returns a rotor equivalent to first apply p, then apply q 42 inout Rotor3 opBinary(string op)(inout Rotor3 q) if (op == "*") 43 { 44 alias p = this; 45 Rotor3 r; 46 r.a = p.a * q.a - p.i * q.i - p.j * q.j - p.k * q.k; 47 r.i = p.i * q.a + p.a * q.i + p.j * q.k - p.k * q.j; 48 r.j = p.j * q.a + p.a * q.j + p.k * q.i - p.i * q.k; 49 r.k = p.k * q.a + p.a * q.k + p.i * q.j - p.j * q.i; 50 return r; 51 } 52 53 inout Vector3 opBinary(string op)(inout Vector3 v) if (op == "*") 54 { 55 Vector3 rv; 56 rv.x = a * v.x + xy * v.y - zx * v.z; 57 rv.y = a * v.y + yz * v.z - xy * v.x; 58 rv.z = a * v.z + zx * v.x - yz * v.y; 59 return rv; 60 } 61 62 inout Vector3 opBinaryRight(string op)(inout Vector3 v) if (op == "*") 63 { 64 Vector3 vr; 65 vr.x = v.x * a - v.y * xy + v.z * zx; 66 vr.y = v.y * a - v.z * yz + v.x * xy; 67 vr.z = v.z * a - v.x * zx + v.y * yz; 68 return vr; 69 } 70 } 71 else 72 { 73 inout T opBinary(string op)(inout T rhs) if (["+", "-"].canFind(op)) 74 { 75 enum fragment = [FieldNameTuple!T].map!(field => field ~ op ~ "rhs." ~ field).join(","); 76 return mixin("T(" ~ fragment ~ ")"); 77 } 78 } 79 80 inout T opBinary(string op)(inout float rhs) if (["+", "-", "*", "/"].canFind(op)) 81 { 82 enum fragment = [FieldNameTuple!T].map!(field => field ~ op ~ "rhs").join(","); 83 return mixin("T(" ~ fragment ~ ")"); 84 } 85 86 inout T opBinaryRight(string op)(inout float lhs) if (["+", "-", "*", "/"].canFind(op)) 87 { 88 enum fragment = [FieldNameTuple!T].map!(field => "lhs" ~ op ~ field).join(","); 89 return mixin("T(" ~ fragment ~ ")"); 90 } 91 } 92 93 unittest 94 { 95 Assert.equal(Vector2.init, Vector2.zero); 96 Assert.equal(Vector2(), Vector2.zero); 97 Assert.equal(-Vector2(1, 2), Vector2(-1, -2)); 98 auto a = Vector3(1, 2, 9); 99 immutable b = Vector3(3, 4, 9); 100 Vector3 c = a + b; 101 Assert.equal(c, Vector3(4, 6, 18)); 102 Assert.equal(4.0f - Vector2.zero, Vector2(4, 4)); 103 Assert.equal(Vector2.one - 3.0f, Vector2(-2, -2)); 104 } 105 106 import std.traits : FieldNameTuple; 107 import std.algorithm : map; 108 import std.range : join; 109 110 float length(T)(T v) 111 { 112 enum fragment = [FieldNameTuple!T].map!(field => "v." ~ field ~ "*" ~ "v." ~ field).join("+"); 113 return mixin("sqrt(" ~ fragment ~ ")"); 114 } 115 116 T normal(T)(T v) 117 { 118 return v / v.length; 119 } 120 121 float distance(T)(T lhs, T rhs) 122 { 123 return (lhs - rhs).length; 124 } 125 126 float dot(T)(T lhs, T rhs) 127 { 128 enum fragment = [FieldNameTuple!T].map!(field => "lhs." ~ field ~ "*" ~ "rhs." ~ field).join( 129 "+"); 130 return mixin(fragment); 131 } 132 133 unittest 134 { 135 Assert.equal(Vector2(3, 4).length, 5); 136 const a = Vector2(-3, 4); 137 Assert.equal(a.normal, Vector2(-3. / 5., 4. / 5.)); 138 immutable b = Vector2(9, 8); 139 Assert.equal(b.distance(Vector2(-3, 3)), 13); 140 Assert.equal(Vector3(2, 3, 4).dot(Vector3(4, 5, 6)), 47); 141 Assert.equal(Vector2.one.length, sqrt(2.0f)); 142 } 143 144 unittest 145 { 146 Assert.equal(Rotor3(1, 2, 3, 4), Rotor3(1, Bivector3(2, 3, 4))); 147 } 148 149 /// Mix `amount` of `lhs` with `1-amount` of `rhs` 150 /// `amount` should be between 0 and 1, but can be anything 151 /// lerp(lhs, rhs, 0) == lhs 152 /// lerp(lhs, rhs, 1) == rhs 153 T lerp(T)(T lhs, T rhs, float amount) 154 { 155 return lhs + amount * (rhs - lhs); 156 } 157 158 /// angle betwenn vector and x-axis (+y +x -> positive) 159 float angle(Vector2 v) 160 { 161 return atan2(v.y, v.x); 162 } 163 164 Vector2 rotate(Vector2 v, float angle) 165 { 166 return Vector2(v.x * cos(angle) - v.y * sin(angle), v.x * sin(angle) + v.y * cos(angle)); 167 } 168 169 Vector2 slide(Vector2 v, Vector2 along) 170 { 171 return along.normal * dot(v, along); 172 } 173 174 Bivector2 wedge(Vector2 lhs, Vector2 rhs) 175 { 176 Bivector2 result = {xy: lhs.x * rhs.y - lhs.y * rhs.x}; 177 return result; 178 } 179 180 // dfmt off 181 Bivector3 wedge(Vector3 lhs, Vector3 rhs) 182 { 183 Bivector3 result = { 184 xy: lhs.x * rhs.y - lhs.y * rhs.x, 185 yz: lhs.y * rhs.z - lhs.z * rhs.y, 186 zx: lhs.z * rhs.x - lhs.x * rhs.z, 187 }; 188 return result; 189 } 190 191 Vector3 transform(Vector3 v, Matrix4 mat) 192 { 193 with (v) with (mat) 194 return Vector3( 195 m0 * x + m4 * y + m8 * z + m12, 196 m1 * x + m5 * y + m9 * z + m13, 197 m2 * x + m6 * y + m10 * z + m14 198 ); 199 } 200 // dfmt on 201 202 Vector3 cross(Vector3 lhs, Vector3 rhs) 203 { 204 auto v = wedge(lhs, rhs); 205 return Vector3(v.yz, v.zx, v.xy); 206 } 207 208 unittest { 209 // TODO 210 } 211 212 /// Returns a unit rotor that rotates `from` to `to` 213 Rotor3 rotation(Vector3 from, Vector3 to) 214 { 215 return Rotor3(1 + dot(to, from), wedge(to, from)).normal; 216 } 217 218 Rotor3 rotation(float angle, Bivector3 plane) 219 { 220 return Rotor3(cos(angle / 2.0f), -sin(angle / 2.0f) * plane); 221 } 222 223 /// Rotate q by p 224 Rotor3 rotate(Rotor3 p, Rotor3 q) 225 { 226 return p * q * p.reverse; 227 } 228 229 /// Rotate v by r 230 Vector3 rotate(Rotor3 r, Vector3 v) 231 { 232 return r * v * r.reverse; 233 } 234 235 Rotor3 reverse(Rotor3 r) 236 { 237 return Rotor3(r.a, -r.b); 238 } 239 240 unittest 241 { 242 // TODO 243 }