affineTransform implementation

Author: Anton Petrov

playdate/affineTransform.lua

@@ -2,33 +2,66 @@ local module = {}
 playdate.geometry.affineTransform = module
 
 local meta = {}
-
 meta.__index = meta
+module.__index = meta
 
-meta.__mul = function(a, b)
-  error("[ERR] playdate.geometry.affineTransform.__mul is not yet implemented.")
+local function concat(a, b)
+  return
+    a.m11 * b.m11 + a.m21 * b.m12,
+    a.m12 * b.m11 + a.m22 * b.m12,
+    a.m11 * b.m21 + a.m21 * b.m22,
+    a.m12 * b.m21 + a.m22 * b.m22,
+    a.tx  * b.m11 + a.ty  * b.m12 + b.tx,
+    a.tx  * b.m21 + a.ty  * b.m22 + b.ty
 end
 
-module.__index = meta
+
+local function transform(t, x, y)
+  return
+    x * t.m11 + y * t.m12 + t.tx,
+    x * t.m21 + y * t.m22 + t.ty
+end
+
+local function translation(dx, dy)
+  return module.new(1, 0, 0, 1, dx, dy)
+end
+
+local function scaling(sx, sy)
+  sy = sy or sx
+  return module.new(sx, 0, 0, sy, 0, 0)
+end
+
+local function rotation(angle)
+  angle = math.rad(angle)
+  local c = math.cos(angle)
+  local s = math.sin(angle)
+  return module.new(c, -s, s, c, 0, 0)
+end
+
+local function rotationAround(angle, px, py)
+  local rad = math.rad(angle)
+  local c = math.cos(rad)
+  local s = math.sin(rad)
+  local tx = px - px * c + py * s
+  local ty = py - px * s - py * c
+  return module.new(c, -s, s, c, tx, ty)
+end
+
+local function skewing(sx, sy)
+  local rx = math.tan(math.rad(sx))
+  local ry = math.tan(math.rad(sy))
+  return module.new(1, rx, ry, 1, 0, 0)
+end
 
 function module.new(m11, m12, m21, m22, tx, ty)
   local o = {}
 
-  if m11 then
-    o.m11 = m11
-    o.m12 = m12
-    o.m21 = m21
-    o.m22 = m22
-    o.tx  = tx
-    o.ty  = ty
-  else
-    o.m11 = 1
-    o.m12 = 0
-    o.m21 = 0
-    o.m22 = 1
-    o.tx  = 0
-    o.ty  = 0
-  end
+  o.m11 = m11 or 1
+  o.m12 = m12 or 0
+  o.m21 = m21 or 0
+  o.m22 = m22 or 1
+  o.tx  = tx  or 0
+  o.ty  = ty  or 0
 
   setmetatable(o, meta)
   return o
@@ -43,7 +76,27 @@ function meta:unpack()
 end
 
 function meta:invert()
-  error("[ERR] playdate.geometry.affineTransform:invert() is not yet implemented.")
+  local a, b   = self.m11, self.m12
+  local c, d   = self.m21, self.m22
+  local tx, ty = self.tx,  self.ty
+
+  local det = a * d - b * c
+  local invDet = 1 / det
+
+  local im11 = d * invDet
+  local im12 = -b * invDet
+  local im21 = -c * invDet
+  local im22 = a * invDet
+
+  local itx = -(im11 * tx + im12 * ty)
+  local ity = -(im21 * tx + im22 * ty)
+
+  self.m11 = im11
+  self.m12 = im12
+  self.m21 = im21
+  self.m22 = im22
+  self.tx  = itx
+  self.ty  = ity
 end
 
 function meta:reset()
@@ -55,88 +108,131 @@ function meta:reset()
   self.ty  = 0
 end
 
-function meta:concat(af)
-  local m11 = self.m11 * af.m11 + self.m12 * af.m21
-  local m12 = self.m11 * af.m12 + self.m12 * af.m22
-
-  local m21 = self.m21 * af.m11 + self.m22 * af.m21
-  local m22 = self.m21 * af.m12 + self.m22 * af.m22
-
-  local tx  = self.m11 * af.tx  + self.m12 * af.ty + self.tx
-  local ty  = self.m21 * af.tx  + self.m22 * af.ty + self.ty
-
-  return module.new(m11, m12, m21, m22, tx, ty)
+function meta:concat(b)
+  self.m11, self.m12, self.m21, self.m22, self.tx, self.ty = concat(self, b)
 end
 
 function meta:translate(dx, dy)
-  error("[ERR] playdate.geometry.affineTransform:translate() is not yet implemented.")
+  local t = translation(dx, dy)
+  self:concat(t)
 end
 
 function meta:translatedBy(dx, dy)
-  error("[ERR] playdate.geometry.affineTransform:translatedBy() is not yet implemented.")
+  local t = self:copy()
+  t:translate(dx, dy)
+  return t
 end
 
 function meta:scale(sx, sy)
-  error("[ERR] playdate.geometry.affineTransform:scale() is not yet implemented.")
+  local t = scaling(sx, sy)
+  self:concat(t)
 end
 
 function meta:scaledBy(sx, sy)
-  error("[ERR] playdate.geometry.affineTransform:scaledBy() is not yet implemented.")
+  local t = self:copy()
+  t:scale(sx, sy)
+  return t
 end
 
-function meta:rotate(angle, pointOrX, y)
-  error("[ERR] playdate.geometry.affineTransform:rotate() is not yet implemented.")
+function meta:rotate(angle, x, y)
+  local t
+
+  if x then
+    if y then
+      t = rotationAround(angle, x, y)
+    else
+      local pt = x
+      t = rotationAround(angle, pt.x, pt.y)
+    end
+  else
+    t = rotation(angle)
+  end
+
+  self:concat(t)
 end
 
-function meta:rotateBy(angle, pointOrX, y)
-  error("[ERR] playdate.geometry.affineTransform:rotateBy() is not yet implemented.")
+function meta:rotatedBy(angle, pointOrX, y)
+  local t = self:copy()
+  t:rotate(angle, pointOrX, y)
+  return t
 end
 
 function meta:skew(sx, sy)
-  error("[ERR] playdate.geometry.affineTransform:skew() is not yet implemented.")
+  local t = skewing(sx, sy)
+  self:concat(t)
 end
 
 function meta:skewedBy(sx, sy)
-  error("[ERR] playdate.geometry.affineTransform:skewedBy() is not yet implemented.")
+  local t = self:copy()
+  t:skew(sx, sy)
+  return t
 end
 
-function meta:transformPoint(p)
-  local nx, ny = self:transformXY(p.x, p.y)
-  p.x = nx
-  p.y = ny
+function meta:transformXY(x, y)
+  return transform(self, x, y)
 end
 
-function meta:transformedPoint(p)
-  local nx, ny = self:transformXY(p.x, p.y)
-  return playdate.geometry.point.new(nx, ny)
+function meta:transformPoint(p)
+  p.x, p.y = transform(self, p.x, p.y)
 end
 
-function meta:transformXY(x, y)
-  local nx = x * self.m11 + y * self.m12 + self.tx
-  local ny = x * self.m21 + y * self.m22 + self.ty
-  return nx, ny
+function meta:transformedPoint(p)
+  local c = p:copy()
+  self:transformPoint(c)
+  return c
 end
 
 function meta:transformLineSegment(ls)
-  error("[ERR] playdate.geometry.affineTransform:transformLineSegment() is not yet implemented.")
+  ls.x1, ls.y1 = transform(self, ls.x1, ls.y1)
+  ls.x2, ls.y2 = transform(self, ls.x2, ls.y2)
 end
 
 function meta:transformedLineSegment(ls)
-  error("[ERR] playdate.geometry.affineTransform:transformedLineSegment() is not yet implemented.")
+  local c = ls:copy()
+  self:transformLineSegment(c)
+  return c
 end
 
 function meta:transformAABB(r)
   error("[ERR] playdate.geometry.affineTransform:transformAABB() is not yet implemented.")
 end
 
 function meta:transformedAABB(r)
-  error("[ERR] playdate.geometry.affineTransform:transformedAABB() is not yet implemented.")
+  local c = r:copy()
+  self:transformAABB(c)
+  return c
 end
 
 function meta:transformPolygon(p)
-  error("[ERR] playdate.geometry.affineTransform:transformPolygon() is not yet implemented.")
+  local pts = p._points
+  for i = 1, #pts, 2 do
+    local j = i + 1
+    pts[i], pts[j] = transform(self, pts[i], pts[j])
+  end
 end
 
 function meta:transformedPolygon(p)
-  error("[ERR] playdate.geometry.affineTransform:transformedPolygon() is not yet implemented.")
+  local c = p:copy()
+  self:transformPolygon(c)
+  return c
 end
+
+meta.__mul = function(a, b)
+  if b._type == "point" then
+    local x, y = transform(a, b.x, b.y)
+    return playdate.geometry.point.new(x, y)
+
+  elseif b._type == "vector2D" then
+    local dx, dy = transform(a, b.dx, b.dy)
+    return playdate.geometry.vector2D.new(dx, dy)
+
+  else
+    local m11, m12, m21, m22, tx, ty = concat(a, b)
+    return module.new(m11, m12, m21, m22, tx, ty)
+  end
+end
+
+meta.__tostring = function(t)
+    return string.format("(m11=%s, m12=%s, m21=%s, m22=%s, tx=%s, ty=%s)",
+      t.m11, t.m12, t.m21, t.m22, t.tx, t.ty)
+end