Mercurial > games > semicongine
annotate src/zamikongine/math/matrix.nim @ 22:b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
| author | Sam <sam@basx.dev> |
|---|---|
| date | Wed, 11 Jan 2023 00:43:17 +0700 |
| parents | b55d6ecde79d |
| children | 71bbe11d8de8 |
| rev | line source |
|---|---|
| 16 | 1 import std/math |
| 2 import std/macros | |
| 3 import std/random | |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
4 import std/strutils |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
5 import std/typetraits |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
6 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
7 import ./vector |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
8 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
9 type |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
10 # layout is row-first |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
11 # having an object instead of directly aliasing the array seems a bit ugly at |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
12 # first, but is necessary to be able to work correctly with distinguished |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
13 # types (i.e. Mat23 and Mat32 would be an alias for the same type array[6, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
14 # which prevents the type system from identifying the correct type at times) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
15 # |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
16 # Though, great news is that objects have zero overhead! |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
17 Mat22*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
18 data: array[4, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
19 Mat23*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
20 data: array[6, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
21 Mat32*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
22 data: array[6, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
23 Mat33*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
24 data: array[9, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
25 Mat34*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
26 data: array[12, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
27 Mat43*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
28 data: array[12, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
29 Mat44*[T: SomeNumber] = object |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
30 data: array[16, T] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
31 MatMM* = Mat22|Mat33|Mat44 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
32 MatMN* = Mat23|Mat32|Mat34|Mat43 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
33 Mat* = MatMM|MatMN |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
34 IntegerMat = Mat22[SomeInteger]|Mat33[SomeInteger]|Mat44[SomeInteger]|Mat23[SomeInteger]|Mat32[SomeInteger]|Mat34[SomeInteger]|Mat43[SomeInteger] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
35 FloatMat = Mat22[SomeFloat]|Mat33[SomeFloat]|Mat44[SomeFloat]|Mat23[SomeFloat]|Mat32[SomeFloat]|Mat34[SomeFloat]|Mat43[SomeFloat] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
36 |
| 16 | 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 ]) | |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
52 |
| 16 | 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 | |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
99 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
100 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
101 func toString[T](value: T): string = |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
102 var |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
103 strvalues: seq[string] |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
104 maxwidth = 0 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
105 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
106 for n in value.data: |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
107 let strval = $n |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
108 strvalues.add(strval) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
109 if strval.len > maxwidth: |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
110 maxwidth = strval.len |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
111 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
112 for i in 0 ..< strvalues.len: |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
113 let filler = " ".repeat(maxwidth - strvalues[i].len) |
| 16 | 114 if i mod T.columnCount == T.columnCount - 1: |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
115 result &= filler & strvalues[i] & "\n" |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
116 else: |
| 16 | 117 if i mod T.columnCount == 0: |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
118 result &= " " |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
119 result &= filler & strvalues[i] & " " |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
120 result = $T & "\n" & result |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
121 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
122 func `$`*(v: Mat22[SomeNumber]): string = toString[Mat22[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
123 func `$`*(v: Mat23[SomeNumber]): string = toString[Mat23[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
124 func `$`*(v: Mat32[SomeNumber]): string = toString[Mat32[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
125 func `$`*(v: Mat33[SomeNumber]): string = toString[Mat33[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
126 func `$`*(v: Mat34[SomeNumber]): string = toString[Mat34[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
127 func `$`*(v: Mat43[SomeNumber]): string = toString[Mat43[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
128 func `$`*(v: Mat44[SomeNumber]): string = toString[Mat44[SomeNumber]](v) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
129 |
| 16 | 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 | |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
132 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
133 func row*[T: Mat22](m: T, i: 0..1): auto = Vec2([m[i, 0], m[i, 1]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
134 func row*[T: Mat32](m: T, i: 0..2): auto = Vec2([m[i, 0], m[i, 1]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
135 func row*[T: Mat23](m: T, i: 0..1): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
136 func row*[T: Mat33](m: T, i: 0..2): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
137 func row*[T: Mat43](m: T, i: 0..3): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
138 func row*[T: Mat34](m: T, i: 0..2): auto = Vec4([m[i, 0], m[i, 1], m[i, 2], m[i, 3]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
139 func row*[T: Mat44](m: T, i: 0..3): auto = Vec4([m[i, 0], m[i, 1], m[i, 2], m[i, 3]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
140 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
141 func col*[T: Mat22](m: T, i: 0..1): auto = Vec2([m[0, i], m[1, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
142 func col*[T: Mat23](m: T, i: 0..2): auto = Vec2([m[0, i], m[1, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
143 func col*[T: Mat32](m: T, i: 0..1): auto = Vec3([m[0, i], m[1, i], m[2, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
144 func col*[T: Mat33](m: T, i: 0..2): auto = Vec3([m[0, i], m[1, i], m[2, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
145 func col*[T: Mat34](m: T, i: 0..3): auto = Vec3([m[0, i], m[1, i], m[2, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
146 func col*[T: Mat43](m: T, i: 0..2): auto = Vec4([m[0, i], m[1, i], m[2, i], m[3, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
147 func col*[T: Mat44](m: T, i: 0..3): auto = Vec4([m[0, i], m[1, i], m[2, i], m[3, i]]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
148 |
| 16 | 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 | |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
306 func transposed*[T](m: Mat22[T]): Mat22[T] = Mat22[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
307 m[0, 0], m[1, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
308 m[0, 1], m[1, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
309 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
310 func transposed*[T](m: Mat23[T]): Mat32[T] = Mat32[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
311 m[0, 0], m[1, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
312 m[0, 1], m[1, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
313 m[0, 2], m[1, 2], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
314 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
315 func transposed*[T](m: Mat32[T]): Mat23[T] = Mat23[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
316 m[0, 0], m[1, 0], m[2, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
317 m[0, 1], m[1, 1], m[2, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
318 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
319 func transposed*[T](m: Mat33[T]): Mat33[T] = Mat33[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
320 m[0, 0], m[1, 0], m[2, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
321 m[0, 1], m[1, 1], m[2, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
322 m[0, 2], m[1, 2], m[2, 2], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
323 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
324 func transposed*[T](m: Mat43[T]): Mat34[T] = Mat34[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
325 m[0, 0], m[1, 0], m[2, 0], m[3, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
326 m[0, 1], m[1, 1], m[2, 1], m[3, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
327 m[0, 2], m[1, 2], m[2, 2], m[3, 2], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
328 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
329 func transposed*[T](m: Mat34[T]): Mat43[T] = Mat43[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
330 m[0, 0], m[1, 0], m[2, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
331 m[0, 1], m[1, 1], m[2, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
332 m[0, 2], m[1, 2], m[2, 2], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
333 m[0, 3], m[1, 3], m[2, 3], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
334 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
335 func transposed*[T](m: Mat44[T]): Mat44[T] = Mat44[T](data: [ |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
336 m[0, 0], m[1, 0], m[2, 0], m[3, 0], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
337 m[0, 1], m[1, 1], m[2, 1], m[3, 1], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
338 m[0, 2], m[1, 2], m[2, 2], m[3, 2], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
339 m[0, 3], m[1, 3], m[2, 3], m[3, 3], |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
340 ]) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
341 |
|
22
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
342 func translate2d*[T](x, y: T): Mat33[T] = Mat33[T](data: [ |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
343 T(1), T(0), x, |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
344 T(0), T(1), y, |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
345 T(0), T(0), T(1), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
346 ]) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
347 func scale2d*[T](sx, sy: T): Mat33[T] = Mat33[T](data: [ |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
348 sx, T(0), T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
349 T(0), sy, T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
350 T(0), T(0), T(1), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
351 ]) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
352 func rotate2d*[T](angle: T): Mat33[T] = Mat33[T](data: [ |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
353 cos(angle), -sin(angle), T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
354 sin(angle), cos(angle), T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
355 T(0), T(0), T(1), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
356 ]) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
357 func translate3d*[T](x, y, z: T): Mat44[T] = Mat44[T](data: [ |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
358 T(1), T(0), T(0), x, |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
359 T(0), T(1), T(0), y, |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
360 T(0), T(0), T(1), z, |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
361 T(0), T(0), T(0), T(1), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
362 ]) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
363 func scale3d*[T](sx, sy, sz: T): Mat44[T] = Mat44[T](data: [ |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
364 sx, T(0), T(0), T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
365 T(0), sy, T(0), T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
366 T(0), T(0), sz, T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
367 T(0), T(0), T(0), T(1), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
368 ]) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
369 func rotate3d*[T](angle: T, a: Vec3[T]): Mat44[T] = |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
370 let |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
371 cosa = cos(angle) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
372 sina = sin(angle) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
373 x = a.x |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
374 y = a.y |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
375 z = a.z |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
376 Mat44[T](data: [ |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
377 x * x * (1 - cosa) + cosa, y * x * (1 - cosa) - z * sina, z * x * (1 - cosa) + y * sina, T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
378 x * y * (1 - cosa) + z * sina, y * y * (1 - cosa) + cosa, z * y * (1 - cosa) - x * sina, T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
379 x * z * (1 - cosa) - y * sina, y * z * (1 - cosa) + x * sina, z * z * (1 - cosa) + cosa, T(0), |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
380 T(0), T(0), T(0), 1, |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
381 ]) |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
382 |
|
b45a5d338cd0
did: improve alotof_triangles example, remove glslang lib, use only binary, easier cross-compilation
Sam <sam@basx.dev>
parents:
19
diff
changeset
|
383 |
| 16 | 384 # call e.g. Mat32[int]().randomized() to get a random matrix |
|
13
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
385 template makeRandomInit(mattype: typedesc) = |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
386 proc randomized*[T: SomeInteger](m: mattype[T]): mattype[T] = |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
387 for i in 0 ..< result.data.len: |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
388 result.data[i] = rand(low(typeof(m.data[0])) .. high(typeof(m.data[0]))) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
389 proc randomized*[T: SomeFloat](m: mattype[T]): mattype[T] = |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
390 for i in 0 ..< result.data.len: |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
391 result.data[i] = rand(1.0) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
392 |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
393 makeRandomInit(Mat22) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
394 makeRandomInit(Mat23) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
395 makeRandomInit(Mat32) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
396 makeRandomInit(Mat33) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
397 makeRandomInit(Mat34) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
398 makeRandomInit(Mat43) |
|
a571db114152
add: vector/matrix modules, tests, nim config script
Sam <sam@basx.dev>
parents:
diff
changeset
|
399 makeRandomInit(Mat44) |