[refactor] factored out affine from unit; made container a unit;

6 files changed, 79 insertions, 66 deletions

diff --git a/src/core-units/affine.lisp b/src/core-units/affine.lisp
new file mode 100644
index 0000000..e4db874
--- /dev/null
+++ b/src/core-units/affine.lisp
@@ -0,0 +1,71 @@
+;;;; affine.lisp
+
+(in-package #:wheelwork)
+
+(defclass/std affine (unit)
+  ((cached-model cached-projected-matrix cached-application :a)
+   (base-width base-height :r :std 1.0 :doc "Determined by content.")
+   (scale-x scale-y :std 1.0)
+   (rotation x y :std 0.0)))
+
+(defmethod (setf closer-mop:slot-value-using-class) :after
+    (newval class (affine affine) slot)
+  (case (closer-mop:slot-definition-name slot)
+    ((x y scale-x scale-y rotation)
+     (setf (cached-model affine) nil
+           (cached-projected-matrix affine) nil))))
+
+(defun scale-by (affine amount)
+  (with-slots (scale-x scale-y) affine
+    (setf scale-x (* amount scale-x)
+          scale-y (* amount scale-y))))
+
+(defun set-width-preserve-aspect (affine new-width)
+  (scale-by affine (/ new-width (unit-width affine))))
+
+(defun set-height-preserve-aspect (affine new-height)
+  (scale-by affine (/ new-height (unit-height affine) )))
+
+(defmethod unit-width ((affine affine))
+  (with-slots (scale-x base-width) affine
+    (* scale-x base-width)))
+
+(defmethod unit-height ((affine affine))
+  (with-slots (scale-y base-height) affine
+    (* scale-y base-height)))
+
+(defmethod (setf unit-width) (newval (affine affine))
+  (with-slots (scale-x base-width) affine
+    (setf scale-x (coerce (/ newval base-width) 'single-float))))
+
+(defmethod (setf unit-height) (newval (affine affine))
+  (with-slots (scale-y base-height) affine
+    (setf scale-y (coerce (/ newval base-height) 'single-float))))
+
+
+
+(defmethod model-matrix :around ((u affine))
+  (or (cached-model u)
+      (setf (cached-model u)
+            (call-next-method))))
+
+(defmethod model-matrix ((u affine))
+  (let ((m (mat:meye 4)))
+    (with-slots (x y base-width scale-x base-height scale-y rotation) u 
+      (let ((uw (* base-width scale-x))
+            (uh (* base-height scale-y)))
+        (mat:nmtranslate m (vec:vec x y 0.0))
+
+        (mat:nmtranslate m (vec:v* 0.5 (vec:vec uw uh 0.0)))
+        (mat:nmrotate  m vec:+vz+ rotation)
+        (mat:nmtranslate m (vec:v* -0.5 (vec:vec uw uh 0.0)))
+        
+        (mat:nmscale m (vec:vec uw uh 1.0))))
+    m))
+
+
+(defun projected-matrix (affine)
+  (or (cached-projected-matrix affine)
+      (setf (cached-projected-matrix affine)
+            (mat:marr (mat:m* (application-projection (app-of-unit affine))
+                              (model-matrix affine))))))
diff --git a/src/core-units/container.lisp b/src/core-units/container.lisp
index afa68b3..af01ff1 100644
--- a/src/core-units/container.lisp
+++ b/src/core-units/container.lisp
@@ -3,7 +3,7 @@
 (in-package #:wheelwork)
 
 
-(defclass/std container ()
+(defclass/std container (unit)
   ((units :with :a))
   (:documentation "Just a list of units. Made into a class so that
   transformation affine transformations methods can be specialzied on
diff --git a/src/core-units/unit.lisp b/src/core-units/unit.lisp
index 31f268c..20e05e2 100644
--- a/src/core-units/unit.lisp
+++ b/src/core-units/unit.lisp
@@ -3,70 +3,15 @@
 (in-package #:wheelwork)
 
 (defclass/std unit ()
-  ((cached-model cached-projected-matrix cached-application :a)
-   (container :with :a)
-   (base-width base-height :r :std 1.0 :doc "Determined by content.")
-   (scale-x scale-y :with :std 1.0)
-   (rotation x y :with :std 0.0)
-   (opacity :std 1.0 :doc "0.0 indicates it will not be rendred.")))
+  ((cached-application  :a)
+   (container :with :a)))
 
 (defmethod (setf closer-mop:slot-value-using-class) :after
     (newval class (unit unit) slot)
   (case (closer-mop:slot-definition-name slot)
-    ((x y scale-x scale-y rotation)
-     (setf (cached-model unit) nil
-           (cached-projected-matrix unit) nil))
     (container
      (setf (cached-application unit) nil))))
 
-(defun scale-by (unit amount)
-  (with-slots (scale-x scale-y) unit
-    (setf scale-x (* amount scale-x)
-          scale-y (* amount scale-y))))
-
-(defun set-width-preserve-aspect (unit new-width)
-  (scale-by unit (/ new-width (unit-width unit))))
-
-(defun set-height-preserve-aspect (unit new-height)
-  (scale-by unit (/ new-height (unit-height unit) )))
-
-(defmethod unit-width ((unit unit))
-  (with-slots (scale-x base-width) unit
-    (* scale-x base-width)))
-
-(defmethod unit-height ((unit unit))
-  (with-slots (scale-y base-height) unit
-    (* scale-y base-height)))
-
-(defmethod (setf unit-width) (newval (unit unit))
-  (with-slots (scale-x base-width) unit
-    (setf scale-x (coerce (/ newval base-width) 'single-float))))
-
-(defmethod (setf unit-height) (newval (unit unit))
-  (with-slots (scale-y base-height) unit
-    (setf scale-y (coerce (/ newval base-height) 'single-float))))
-
-
-
-(defmethod model-matrix :around ((u unit))
-  (or (cached-model u)
-      (setf (cached-model u)
-            (call-next-method))))
-
-(defmethod model-matrix ((u unit))
-  (let ((m (mat:meye 4)))
-    (with-slots (x y base-width scale-x base-height scale-y rotation) u 
-      (let ((uw (* base-width scale-x))
-            (uh (* base-height scale-y)))
-        (mat:nmtranslate m (vec:vec x y 0.0))
-
-        (mat:nmtranslate m (vec:v* 0.5 (vec:vec uw uh 0.0)))
-        (mat:nmrotate  m vec:+vz+ rotation)
-        (mat:nmtranslate m (vec:v* -0.5 (vec:vec uw uh 0.0)))
-        
-        (mat:nmscale m (vec:vec uw uh 1.0))))
-    m))
-
 
 (defun app-of-unit (unit)
   "Returns the APPLICATION instance, if any, of which this UNIT is a
@@ -82,8 +27,4 @@ in this application."
                            (null nil)))))
               (rec unit)))))
 
-(defun projected-matrix (unit)
-  (or (cached-projected-matrix unit)
-      (setf (cached-projected-matrix unit)
-            (mat:marr (mat:m* (application-projection (app-of-unit unit))
-                              (model-matrix unit))))))
+
diff --git a/src/interactive-units/bitmap.lisp b/src/interactive-units/bitmap.lisp
index 95dfff5..cc4b4f7 100644
--- a/src/interactive-units/bitmap.lisp
+++ b/src/interactive-units/bitmap.lisp
@@ -2,7 +2,7 @@
 
 (in-package #:wheelwork)
 
-(defclass/std bitmap (unit interactive)
+(defclass/std bitmap (affine interactive)
   ((texture :ri :std (error "A bitmap requires a texture."))
    (vao shader :with :r :static)))
 
@@ -57,6 +57,7 @@
       (gl:delete-program shader))
     (setf vao nil
           shader nil)))
+
 (defmethod render ((bitmap bitmap))
   (with-slots (texture vao shader) bitmap
     (gl:active-texture 0)
diff --git a/src/interactive-units/text.lisp b/src/interactive-units/text.lisp
index 1cecdbf..caba48e 100644
--- a/src/interactive-units/text.lisp
+++ b/src/interactive-units/text.lisp
@@ -2,7 +2,7 @@
 
 (in-package #:wheelwork)
 
-(defclass/std text (unit interactive)
+(defclass/std text (affine interactive)
   ((font :with :ri :std (error "A font is required") :type font)
    (content :with :ri :std "")
    (color :with :std #(1.0 1.0 1.0 1.0))
diff --git a/src/wheelwork.lisp b/src/wheelwork.lisp
index b6da6b9..885ae1e 100644
--- a/src/wheelwork.lisp
+++ b/src/wheelwork.lisp
@@ -66,7 +66,7 @@ TARGET is FOCUSABLEP"
 (defun get-rect (unit)
   "Returns a list of vectors representing the path of the smallest
 rectangle that encloses the unit. The rectangle is scaled and rotated."
-  (with-accessors ((x unit-x) (y unit-y) (w unit-width) (h unit-height) (r unit-rotation)) unit
+  (with-accessors ((x x) (y y) (w unit-width) (h unit-height) (r rotation)) unit
     (let ((m
             (mat:meye 4))
           (tr