|
478
|
1 import std/math
|
|
|
2 import std/macros
|
|
|
3 import std/random
|
|
|
4 import std/strutils
|
|
|
5 import std/typetraits
|
|
|
6
|
|
|
7 import ./vector
|
|
|
8
|
|
|
9 type
|
|
|
10 # layout is row-first
|
|
|
11 # having an object instead of directly aliasing the array seems a bit ugly at
|
|
|
12 # first, but is necessary to be able to work correctly with distinguished
|
|
|
13 # types (i.e. Mat23 and Mat32 would be an alias for the same type array[6, T]
|
|
|
14 # which prevents the type system from identifying the correct type at times)
|
|
|
15 #
|
|
|
16 # Though, great news is that objects have zero overhead!
|
|
|
17 Mat22*[T: SomeNumber] = object
|
|
|
18 data: array[4, T]
|
|
|
19 Mat23*[T: SomeNumber] = object
|
|
|
20 data: array[6, T]
|
|
|
21 Mat32*[T: SomeNumber] = object
|
|
|
22 data: array[6, T]
|
|
|
23 Mat33*[T: SomeNumber] = object
|
|
|
24 data: array[9, T]
|
|
|
25 Mat34*[T: SomeNumber] = object
|
|
|
26 data: array[12, T]
|
|
|
27 Mat43*[T: SomeNumber] = object
|
|
|
28 data: array[12, T]
|
|
|
29 Mat44*[T: SomeNumber] = object
|
|
|
30 data: array[16, T]
|
|
|
31 MatMM* = Mat22|Mat33|Mat44
|
|
|
32 MatMN* = Mat23|Mat32|Mat34|Mat43
|
|
|
33 Mat* = MatMM|MatMN
|
|
|
34 IntegerMat = Mat22[SomeInteger]|Mat33[SomeInteger]|Mat44[SomeInteger]|Mat23[SomeInteger]|Mat32[SomeInteger]|Mat34[SomeInteger]|Mat43[SomeInteger]
|
|
|
35 FloatMat = Mat22[SomeFloat]|Mat33[SomeFloat]|Mat44[SomeFloat]|Mat23[SomeFloat]|Mat32[SomeFloat]|Mat34[SomeFloat]|Mat43[SomeFloat]
|
|
|
36
|
|
|
37 func unit22[T: SomeNumber](): auto {.compiletime.} = Mat22[T](data:[
|
|
|
38 T(1), T(0),
|
|
|
39 T(0), T(1),
|
|
|
40 ])
|
|
|
41 func unit33[T: SomeNumber](): auto {.compiletime.} = Mat33[T](data:[
|
|
|
42 T(1), T(0), T(0),
|
|
|
43 T(0), T(1), T(0),
|
|
|
44 T(0), T(0), T(1),
|
|
|
45 ])
|
|
|
46 func unit44[T: SomeNumber](): auto {.compiletime.} = Mat44[T](data: [
|
|
|
47 T(1), T(0), T(0), T(0),
|
|
|
48 T(0), T(1), T(0), T(0),
|
|
|
49 T(0), T(0), T(1), T(0),
|
|
|
50 T(0), T(0), T(0), T(1),
|
|
|
51 ])
|
|
|
52
|
|
|
53 # generates constants: Unit
|
|
|
54 # Also for Y, Z, R, G, B
|
|
|
55 # not sure if this is necessary or even a good idea...
|
|
|
56 macro generateAllConsts() =
|
|
|
57 result = newStmtList()
|
|
|
58 for theType in ["int", "int8", "int16", "int32", "int64", "float", "float32", "float64"]:
|
|
|
59 var typename = theType[0 .. 0]
|
|
|
60 if theType[^2].isDigit:
|
|
|
61 typename = typename & theType[^2]
|
|
|
62 if theType[^1].isDigit:
|
|
|
63 typename = typename & theType[^1]
|
|
|
64 result.add(newConstStmt(
|
|
|
65 postfix(ident("Unit22" & typename), "*"),
|
|
|
66 newCall(nnkBracketExpr.newTree(ident("unit22"), ident(theType)))
|
|
|
67 ))
|
|
|
68 result.add(newConstStmt(
|
|
|
69 postfix(ident("Unit33" & typename), "*"),
|
|
|
70 newCall(nnkBracketExpr.newTree(ident("unit33"), ident(theType)))
|
|
|
71 ))
|
|
|
72 result.add(newConstStmt(
|
|
|
73 postfix(ident("Unit44" & typename), "*"),
|
|
|
74 newCall(nnkBracketExpr.newTree(ident("unit44"), ident(theType)))
|
|
|
75 ))
|
|
|
76
|
|
|
77 generateAllConsts()
|
|
|
78
|
|
|
79 const Unit22* = unit22[float]()
|
|
|
80 const Unit33* = unit33[float]()
|
|
|
81 const Unit44* = unit44[float]()
|
|
|
82
|
|
|
83 template rowCount*(m: typedesc): int =
|
|
|
84 when m is Mat22: 2
|
|
|
85 elif m is Mat23: 2
|
|
|
86 elif m is Mat32: 3
|
|
|
87 elif m is Mat33: 3
|
|
|
88 elif m is Mat34: 3
|
|
|
89 elif m is Mat43: 4
|
|
|
90 elif m is Mat44: 4
|
|
|
91 template columnCount*(m: typedesc): int =
|
|
|
92 when m is Mat22: 2
|
|
|
93 elif m is Mat23: 3
|
|
|
94 elif m is Mat32: 2
|
|
|
95 elif m is Mat33: 3
|
|
|
96 elif m is Mat34: 4
|
|
|
97 elif m is Mat43: 3
|
|
|
98 elif m is Mat44: 4
|
|
|
99
|
|
|
100
|
|
|
101 func toString[T](value: T): string =
|
|
|
102 var
|
|
|
103 strvalues: seq[string]
|
|
|
104 maxwidth = 0
|
|
|
105
|
|
|
106 for n in value.data:
|
|
|
107 let strval = $n
|
|
|
108 strvalues.add(strval)
|
|
|
109 if strval.len > maxwidth:
|
|
|
110 maxwidth = strval.len
|
|
|
111
|
|
|
112 for i in 0 ..< strvalues.len:
|
|
|
113 let filler = " ".repeat(maxwidth - strvalues[i].len)
|
|
|
114 if i mod T.columnCount == T.columnCount - 1:
|
|
|
115 result &= filler & strvalues[i] & "\n"
|
|
|
116 else:
|
|
|
117 if i mod T.columnCount == 0:
|
|
|
118 result &= " "
|
|
|
119 result &= filler & strvalues[i] & " "
|
|
|
120 result = $T & "\n" & result
|
|
|
121
|
|
|
122 func `$`*(v: Mat22[SomeNumber]): string = toString[Mat22[SomeNumber]](v)
|
|
|
123 func `$`*(v: Mat23[SomeNumber]): string = toString[Mat23[SomeNumber]](v)
|
|
|
124 func `$`*(v: Mat32[SomeNumber]): string = toString[Mat32[SomeNumber]](v)
|
|
|
125 func `$`*(v: Mat33[SomeNumber]): string = toString[Mat33[SomeNumber]](v)
|
|
|
126 func `$`*(v: Mat34[SomeNumber]): string = toString[Mat34[SomeNumber]](v)
|
|
|
127 func `$`*(v: Mat43[SomeNumber]): string = toString[Mat43[SomeNumber]](v)
|
|
|
128 func `$`*(v: Mat44[SomeNumber]): string = toString[Mat44[SomeNumber]](v)
|
|
|
129
|
|
|
130 func `[]`*[T: Mat](m: T, row, col: int): auto = m.data[col + row * T.columnCount]
|
|
|
131 proc `[]=`*[T: Mat, U](m: var T, row, col: int, value: U) = m.data[col + row * T.columnCount] = value
|
|
|
132
|
|
|
133 func row*[T: Mat22](m: T, i: 0..1): auto = Vec2([m[i, 0], m[i, 1]])
|
|
|
134 func row*[T: Mat32](m: T, i: 0..2): auto = Vec2([m[i, 0], m[i, 1]])
|
|
|
135 func row*[T: Mat23](m: T, i: 0..1): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]])
|
|
|
136 func row*[T: Mat33](m: T, i: 0..2): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]])
|
|
|
137 func row*[T: Mat43](m: T, i: 0..3): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]])
|
|
|
138 func row*[T: Mat34](m: T, i: 0..2): auto = Vec4([m[i, 0], m[i, 1], m[i, 2], m[i, 3]])
|
|
|
139 func row*[T: Mat44](m: T, i: 0..3): auto = Vec4([m[i, 0], m[i, 1], m[i, 2], m[i, 3]])
|
|
|
140
|
|
|
141 func col*[T: Mat22](m: T, i: 0..1): auto = Vec2([m[0, i], m[1, i]])
|
|
|
142 func col*[T: Mat23](m: T, i: 0..2): auto = Vec2([m[0, i], m[1, i]])
|
|
|
143 func col*[T: Mat32](m: T, i: 0..1): auto = Vec3([m[0, i], m[1, i], m[2, i]])
|
|
|
144 func col*[T: Mat33](m: T, i: 0..2): auto = Vec3([m[0, i], m[1, i], m[2, i]])
|
|
|
145 func col*[T: Mat34](m: T, i: 0..3): auto = Vec3([m[0, i], m[1, i], m[2, i]])
|
|
|
146 func col*[T: Mat43](m: T, i: 0..2): auto = Vec4([m[0, i], m[1, i], m[2, i], m[3, i]])
|
|
|
147 func col*[T: Mat44](m: T, i: 0..3): auto = Vec4([m[0, i], m[1, i], m[2, i], m[3, i]])
|
|
|
148
|
|
|
149 proc createMatMatMultiplicationOperator(leftType: typedesc, rightType: typedesc, outType: typedesc): NimNode =
|
|
|
150 var data = nnkBracket.newTree()
|
|
|
151 for i in 0 ..< rowCount(leftType):
|
|
|
152 for j in 0 ..< rightType.columnCount:
|
|
|
153 data.add(newCall(
|
|
|
154 ident("sum"),
|
|
|
155 infix(
|
|
|
156 newCall(newDotExpr(ident("a"), ident("row")), newLit(i)),
|
|
|
157 "*",
|
|
|
158 newCall(newDotExpr(ident("b"), ident("col")), newLit(j))
|
|
|
159 )
|
|
|
160 ))
|
|
|
161
|
|
|
162 return newProc(
|
|
|
163 postfix(nnkAccQuoted.newTree(ident("*")), "*"),
|
|
|
164 params=[
|
|
|
165 ident("auto"),
|
|
|
166 newIdentDefs(ident("a"), ident(leftType.name)),
|
|
|
167 newIdentDefs(ident("b"), ident(rightType.name))
|
|
|
168 ],
|
|
|
169 body=nnkObjConstr.newTree(ident(outType.name), nnkExprColonExpr.newTree(ident("data"), data)),
|
|
|
170 procType=nnkFuncDef,
|
|
|
171 )
|
|
|
172
|
|
|
173 proc createVecMatMultiplicationOperator(matType: typedesc, vecType: typedesc): NimNode =
|
|
|
174 var data = nnkBracket.newTree()
|
|
|
175 for i in 0 ..< matType.rowCount:
|
|
|
176 data.add(newCall(
|
|
|
177 ident("sum"),
|
|
|
178 infix(
|
|
|
179 ident("v"),
|
|
|
180 "*",
|
|
|
181 newCall(newDotExpr(ident("m"), ident("row")), newLit(i))
|
|
|
182 )
|
|
|
183 ))
|
|
|
184
|
|
|
185 let resultVec = newCall(
|
|
|
186 nnkBracketExpr.newTree(ident(vecType.name), ident("T")),
|
|
|
187 data,
|
|
|
188 )
|
|
|
189 let name = postfix(nnkAccQuoted.newTree(ident("*")), "*")
|
|
|
190 let genericParams = nnkGenericParams.newTree(nnkIdentDefs.newTree(ident("T"), ident("SomeNumber"), newEmptyNode()))
|
|
|
191 let formalParams = nnkFormalParams.newTree(
|
|
|
192 ident("auto"),
|
|
|
193 newIdentDefs(ident("m"), nnkBracketExpr.newTree(ident(matType.name), ident("T"))),
|
|
|
194 newIdentDefs(ident("v"), nnkBracketExpr.newTree(ident(vecType.name), ident("T"))),
|
|
|
195 )
|
|
|
196
|
|
|
197 return nnkFuncDef.newTree(
|
|
|
198 name,
|
|
|
199 newEmptyNode(),
|
|
|
200 genericParams,
|
|
|
201 formalParams,
|
|
|
202 newEmptyNode(),
|
|
|
203 newEmptyNode(),
|
|
|
204 resultVec
|
|
|
205 )
|
|
|
206
|
|
|
207 proc createVecMatMultiplicationOperator1(vecType: typedesc, matType: typedesc): NimNode =
|
|
|
208 var data = nnkBracket.newTree()
|
|
|
209 for i in 0 ..< matType.columnCount:
|
|
|
210 data.add(newCall(
|
|
|
211 ident("sum"),
|
|
|
212 infix(
|
|
|
213 ident("v"),
|
|
|
214 "*",
|
|
|
215 newCall(newDotExpr(ident("m"), ident("col")), newLit(i))
|
|
|
216 )
|
|
|
217 ))
|
|
|
218 let resultVec = nnkObjConstr.newTree(
|
|
|
219 nnkBracketExpr.newTree(ident(vecType.name), ident("float")),
|
|
|
220 nnkExprColonExpr.newTree(ident("data"), data)
|
|
|
221 )
|
|
|
222
|
|
|
223 return nnkFuncDef.newTree(
|
|
|
224 ident("test"),
|
|
|
225 newEmptyNode(),
|
|
|
226 newEmptyNode(),
|
|
|
227 newEmptyNode(),
|
|
|
228 newEmptyNode(),
|
|
|
229 newEmptyNode(),
|
|
|
230 resultVec,
|
|
|
231 )
|
|
|
232
|
|
|
233 proc createMatScalarOperator(matType: typedesc, op: string): NimNode =
|
|
|
234 result = newStmtList()
|
|
|
235
|
|
|
236 var data = nnkBracket.newTree()
|
|
|
237 for i in 0 ..< matType.rowCount * matType.columnCount:
|
|
|
238 data.add(infix(nnkBracketExpr.newTree(newDotExpr(ident("a"), ident("data")), newLit(i)), op, ident("b")))
|
|
|
239 result.add(newProc(
|
|
|
240 postfix(nnkAccQuoted.newTree(ident(op)), "*"),
|
|
|
241 params=[
|
|
|
242 ident("auto"),
|
|
|
243 newIdentDefs(ident("a"), ident(matType.name)),
|
|
|
244 newIdentDefs(ident("b"), ident("SomeNumber")),
|
|
|
245 ],
|
|
|
246 body=nnkObjConstr.newTree(ident(matType.name), nnkExprColonExpr.newTree(ident("data"), data)),
|
|
|
247 procType=nnkFuncDef,
|
|
|
248 ))
|
|
|
249 result.add(newProc(
|
|
|
250 postfix(nnkAccQuoted.newTree(ident(op)), "*"),
|
|
|
251 params=[
|
|
|
252 ident("auto"),
|
|
|
253 newIdentDefs(ident("b"), ident("SomeNumber")),
|
|
|
254 newIdentDefs(ident("a"), ident(matType.name)),
|
|
|
255 ],
|
|
|
256 body=nnkObjConstr.newTree(ident(matType.name), nnkExprColonExpr.newTree(ident("data"), data)),
|
|
|
257 procType=nnkFuncDef,
|
|
|
258 ))
|
|
|
259 if op == "-":
|
|
|
260 var data2 = nnkBracket.newTree()
|
|
|
261 for i in 0 ..< matType.rowCount * matType.columnCount:
|
|
|
262 data2.add(prefix(nnkBracketExpr.newTree(newDotExpr(ident("a"), ident("data")), newLit(i)), op))
|
|
|
263 result.add(newProc(
|
|
|
264 postfix(nnkAccQuoted.newTree(ident(op)), "*"),
|
|
|
265 params=[
|
|
|
266 ident("auto"),
|
|
|
267 newIdentDefs(ident("a"), ident(matType.name)),
|
|
|
268 ],
|
|
|
269 body=nnkObjConstr.newTree(ident(matType.name), nnkExprColonExpr.newTree(ident("data"), data2)),
|
|
|
270 procType=nnkFuncDef,
|
|
|
271 ))
|
|
|
272
|
|
|
273 macro createAllMultiplicationOperators() =
|
|
|
274 result = newStmtList()
|
|
|
275
|
|
|
276 for op in ["+", "-", "*", "/"]:
|
|
|
277 result.add(createMatScalarOperator(Mat22, op))
|
|
|
278 result.add(createMatScalarOperator(Mat23, op))
|
|
|
279 result.add(createMatScalarOperator(Mat32, op))
|
|
|
280 result.add(createMatScalarOperator(Mat33, op))
|
|
|
281 result.add(createMatScalarOperator(Mat34, op))
|
|
|
282 result.add(createMatScalarOperator(Mat43, op))
|
|
|
283 result.add(createMatScalarOperator(Mat44, op))
|
|
|
284
|
|
|
285 result.add(createMatMatMultiplicationOperator(Mat22, Mat22, Mat22))
|
|
|
286 result.add(createMatMatMultiplicationOperator(Mat22, Mat23, Mat23))
|
|
|
287 result.add(createMatMatMultiplicationOperator(Mat23, Mat32, Mat22))
|
|
|
288 result.add(createMatMatMultiplicationOperator(Mat23, Mat33, Mat23))
|
|
|
289 result.add(createMatMatMultiplicationOperator(Mat32, Mat22, Mat32))
|
|
|
290 result.add(createMatMatMultiplicationOperator(Mat32, Mat23, Mat33))
|
|
|
291 result.add(createMatMatMultiplicationOperator(Mat33, Mat32, Mat32))
|
|
|
292 result.add(createMatMatMultiplicationOperator(Mat33, Mat33, Mat33))
|
|
|
293 result.add(createMatMatMultiplicationOperator(Mat33, Mat34, Mat34))
|
|
|
294 result.add(createMatMatMultiplicationOperator(Mat43, Mat33, Mat43))
|
|
|
295 result.add(createMatMatMultiplicationOperator(Mat43, Mat34, Mat44))
|
|
|
296 result.add(createMatMatMultiplicationOperator(Mat44, Mat43, Mat43))
|
|
|
297 result.add(createMatMatMultiplicationOperator(Mat44, Mat44, Mat44))
|
|
|
298
|
|
|
299 result.add(createVecMatMultiplicationOperator(Mat22, Vec2))
|
|
|
300 result.add(createVecMatMultiplicationOperator(Mat33, Vec3))
|
|
|
301 result.add(createVecMatMultiplicationOperator(Mat44, Vec4))
|
|
|
302
|
|
|
303 createAllMultiplicationOperators()
|
|
|
304
|
|
|
305
|
|
|
306 func transposed*[T](m: Mat22[T]): Mat22[T] = Mat22[T](data: [
|
|
|
307 m[0, 0], m[1, 0],
|
|
|
308 m[0, 1], m[1, 1],
|
|
|
309 ])
|
|
|
310 func transposed*[T](m: Mat23[T]): Mat32[T] = Mat32[T](data: [
|
|
|
311 m[0, 0], m[1, 0],
|
|
|
312 m[0, 1], m[1, 1],
|
|
|
313 m[0, 2], m[1, 2],
|
|
|
314 ])
|
|
|
315 func transposed*[T](m: Mat32[T]): Mat23[T] = Mat23[T](data: [
|
|
|
316 m[0, 0], m[1, 0], m[2, 0],
|
|
|
317 m[0, 1], m[1, 1], m[2, 1],
|
|
|
318 ])
|
|
|
319 func transposed*[T](m: Mat33[T]): Mat33[T] = Mat33[T](data: [
|
|
|
320 m[0, 0], m[1, 0], m[2, 0],
|
|
|
321 m[0, 1], m[1, 1], m[2, 1],
|
|
|
322 m[0, 2], m[1, 2], m[2, 2],
|
|
|
323 ])
|
|
|
324 func transposed*[T](m: Mat43[T]): Mat34[T] = Mat34[T](data: [
|
|
|
325 m[0, 0], m[1, 0], m[2, 0], m[3, 0],
|
|
|
326 m[0, 1], m[1, 1], m[2, 1], m[3, 1],
|
|
|
327 m[0, 2], m[1, 2], m[2, 2], m[3, 2],
|
|
|
328 ])
|
|
|
329 func transposed*[T](m: Mat34[T]): Mat43[T] = Mat43[T](data: [
|
|
|
330 m[0, 0], m[1, 0], m[2, 0],
|
|
|
331 m[0, 1], m[1, 1], m[2, 1],
|
|
|
332 m[0, 2], m[1, 2], m[2, 2],
|
|
|
333 m[0, 3], m[1, 3], m[2, 3],
|
|
|
334 ])
|
|
|
335 func transposed*[T](m: Mat44[T]): Mat44[T] = Mat44[T](data: [
|
|
|
336 m[0, 0], m[1, 0], m[2, 0], m[3, 0],
|
|
|
337 m[0, 1], m[1, 1], m[2, 1], m[3, 1],
|
|
|
338 m[0, 2], m[1, 2], m[2, 2], m[3, 2],
|
|
|
339 m[0, 3], m[1, 3], m[2, 3], m[3, 3],
|
|
|
340 ])
|
|
|
341
|
|
|
342 # call e.g. Mat32[int]().randomized() to get a random matrix
|
|
|
343 template makeRandomInit(mattype: typedesc) =
|
|
|
344 proc randomized*[T: SomeInteger](m: mattype[T]): mattype[T] =
|
|
|
345 for i in 0 ..< result.data.len:
|
|
|
346 result.data[i] = rand(low(typeof(m.data[0])) .. high(typeof(m.data[0])))
|
|
|
347 proc randomized*[T: SomeFloat](m: mattype[T]): mattype[T] =
|
|
|
348 for i in 0 ..< result.data.len:
|
|
|
349 result.data[i] = rand(1.0)
|
|
|
350
|
|
|
351 makeRandomInit(Mat22)
|
|
|
352 makeRandomInit(Mat23)
|
|
|
353 makeRandomInit(Mat32)
|
|
|
354 makeRandomInit(Mat33)
|
|
|
355 makeRandomInit(Mat34)
|
|
|
356 makeRandomInit(Mat43)
|
|
|
357 makeRandomInit(Mat44)
|
