matrix: rewrite in pure Python, optimize for 2D affine matrices

marcan · marcan · commit 531c7013b0f3 · 2018-09-05T19:12:58.000+09:00
This is faster than NumPy...
diff --git a/blitzloop/backend/common.py b/blitzloop/backend/common.py
@@ -73,8 +73,8 @@ def set_aspect(self, aspect):
         self.aspect_cache[self.aspect] = matrix
 
     def commit_matrix(self, uniform):
-        m = self.viewmatrix.m * self.matrix.m
-        self.gl.glUniformMatrix4fv(uniform, 1, False, m.transpose())
+        m = self.viewmatrix * self.matrix
+        self.gl.glUniformMatrix4fv(uniform, 1, False, m.m)
 
     def set_render_gen(self, gen):
         self.frames = gen()
diff --git a/blitzloop/matrix.py b/blitzloop/matrix.py
@@ -16,39 +16,118 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-
-import numpy as np
-
 class Matrix(object):
-    def __init__(self):
+    def __init__(self, other=None, nice=None):
         self.stack = []
-        self.reset()
+        if other is not None:
+            if isinstance(other, list):
+                self.m = other
+                self.nice = False
+            else:
+                self.m = list(other.m)
+                self.nice = other.nice
+        else:
+            self.reset()
+
+        if nice is not None:
+            self.nice = nice
 
     def reset(self):
-        self.m = np.matrix([
-            [1,0,0,0],
-            [0,1,0,0],
-            [0,0,1,0],
-            [0,0,0,1]], float)
+        self.m = [
+            1.0,0.0,0.0,0.0,
+            0.0,1.0,0.0,0.0,
+            0.0,0.0,1.0,0.0,
+            0.0,0.0,0.0,1.0
+        ]
+        self.nice = True
 
     def push(self):
-        self.stack.append(self.m.copy())
+        self.stack.append((self.m, self.nice))
+        self.m = list(self.m)
 
     def pop(self):
-        self.m = self.stack.pop()
+        self.m, self.nice = self.stack.pop()
 
     def scale(self, sx, sy, sz=1.0):
-        self.m *= [
-            [sx, 0, 0, 0],
-            [0, sy, 0, 0],
-            [0, 0, sz, 0],
-            [0, 0, 0, 1],
-        ]
+        if not self.nice:
+            self *= Matrix().scale(sx, sy, sz)
+            return self
+        else:
+            self.m[0] *= sx
+            self.m[5] *= sy
+            self.m[10] *= sz
+        return self
 
     def translate(self, tx, ty, tz=0.0):
-        self.m *= [
-            [1, 0, 0, tx],
-            [0, 1, 0, ty],
-            [0, 0, 1, tz],
-            [0, 0, 0, 1],
+        if not self.nice:
+            self *= Matrix().translate(tx, ty, tz)
+            return self
+        self.m[12] += tx * self.m[0]
+        self.m[13] += ty * self.m[5]
+        self.m[14] += tz * self.m[10]
+        return self
+
+    def __mul__(self, other):
+        if self.nice and other.nice:
+            return Matrix(self._nicemult(self.m, other.m), True)
+        else:
+            return Matrix(self._mult(self.m, other.m), False)
+
+    def __imul__(self, other):
+        if self.nice and other.nice:
+            self.m = self._nicemult(self.m, other.m)
+        else:
+            self.m = self._mult(self.m, other.m)
+            self.nice = False
+        return self
+
+    @staticmethod
+    def _mult(B, A):
+        C = [
+            A[0] * B[0] + A[1] * B[4] + A[2] * B[8] + A[3] * B[12],
+            A[0] * B[1] + A[1] * B[5] + A[2] * B[9] + A[3] * B[13],
+            A[0] * B[2] + A[1] * B[6] + A[2] * B[10] + A[3] * B[14],
+            A[0] * B[3] + A[1] * B[7] + A[2] * B[11] + A[3] * B[15],
+            A[4] * B[0] + A[5] * B[4] + A[6] * B[8] + A[7] * B[12],
+            A[4] * B[1] + A[5] * B[5] + A[6] * B[9] + A[7] * B[13],
+            A[4] * B[2] + A[5] * B[6] + A[6] * B[10] + A[7] * B[14],
+            A[4] * B[3] + A[5] * B[7] + A[6] * B[11] + A[7] * B[15],
+            A[8] * B[0] + A[9] * B[4] + A[10] * B[8] + A[11] * B[12],
+            A[8] * B[1] + A[9] * B[5] + A[10] * B[9] + A[11] * B[13],
+            A[8] * B[2] + A[9] * B[6] + A[10] * B[10] + A[11] * B[14],
+            A[8] * B[3] + A[9] * B[7] + A[10] * B[11] + A[11] * B[15],
+            A[12] * B[0] + A[13] * B[4] + A[14] * B[8] + A[15] * B[12],
+            A[12] * B[1] + A[13] * B[5] + A[14] * B[9] + A[15] * B[13],
+            A[12] * B[2] + A[13] * B[6] + A[14] * B[10] + A[15] * B[14],
+            A[12] * B[3] + A[13] * B[7] + A[14] * B[11] + A[15] * B[15],
+        ]
+        return C
+
+    @staticmethod
+    def _nicemult(B, A):
+        C = [
+            A[0] * B[0], 0.0, 0.0, 0.0,
+            0.0, A[5] * B[5], 0.0, 0.0,
+            0.0, 0.0, A[10] * B[10], 0.0,
+            A[12] * B[0] + B[12], A[13] * B[5] + B[13], A[14] * B[10] + B[14], 1.0,
         ]
+        return C
+    
+    def __str__(self):
+        s = ""
+        for i in range(4):
+            s += " [" + ",".join("%d" % self.m[4*j+i] for j in range(4)) + "],\n"
+        return "[\n" + s + "]\n"
+
+    def __eq__(self, other):
+        return self.m == other.m
+
+if __name__ == "__main__":
+    assert Matrix().translate(1,2).translate(3,4) == Matrix().translate(4,6)
+    assert Matrix().scale(1,2).scale(3,4) == Matrix().scale(3,8)
+    assert Matrix().scale(2,3).translate(4,5) == Matrix().translate(8,15).scale(2,3)
+    assert Matrix().scale(2,3).translate(4,5) == Matrix().scale(2,3) * Matrix().translate(4,5)
+    assert Matrix(nice=False).translate(1,2).translate(3,4) == Matrix().translate(4,6)
+    assert Matrix(nice=False).scale(1,2).scale(3,4) == Matrix().scale(3,8)
+    assert Matrix(nice=False).scale(2,3).translate(4,5) == Matrix().translate(8,15).scale(2,3)
+    assert Matrix(nice=False).scale(2,3).translate(4,5) == Matrix().scale(2,3) * Matrix().translate(4,5)
diff --git a/blitzloop/renderer/gles.py b/blitzloop/renderer/gles.py
@@ -417,7 +417,7 @@ def draw(self, pos, size, tpos, tsize, color):
         self.tmatrix.reset()
         self.tmatrix.translate(*tpos)
         self.tmatrix.scale(*tsize)
-        gl.glUniformMatrix4fv(self.l_textransform, 1, False, self.tmatrix.m.transpose())
+        gl.glUniformMatrix4fv(self.l_textransform, 1, False, self.tmatrix.m)
         SolidRenderer.draw(self, pos, size, color)
 
 class ImageTexture(object):
