anchor.diff:                (- zfar znear)))
           (f (/ (* -2 znear zfar)
                 (- zfar znear))))
  -    (sb-cga:matrix   a  0.0     c  0.0
  -                   0.0    b     d  0.0
  -                   0.0  0.0     e    f
  -                   0.0  0.0  -1.0  0.0)))
  +    (sb-cga:matrix   a    0.0     c  0.0
  +                     0.0    b     d  0.0
  +                     0.0  0.0     e    f
  +                     0.0  0.0  -1.0  0.0)))
   
   ;; ----------------------------------------------------------------------------
   (defun perspective (fov aspect znear zfar)
     (let* ((ymax (SFFloat (* znear
  -                          (tan (radians (SFFloat (/ fov 2)))))))
  +                           (tan (radians (SFFloat (/ fov 2)))))))
            (ymin (- ymax))
            (xmin (* ymin aspect))
            (xmax (* ymax aspect)))
  
positive.code:         (b (coerce y 'single-float))
          (c (coerce z 'single-float)))
      (vector a b c 1.0)))
  
  ;; (defmethod MFColor (x y z)
  ;;   (let ((a (coerce x 'single-float))
  ;;         (b (coerce y 'single-float))
  ;;         (c (coerce z 'single-float)))
  ;;     (cl:vector a b c 1.0)))
  
  ;; ----------------------------------------------------------------------------
  (defmethod IntensityType(str)
  
negative.code:           'single-float))
  
  ;; ----------------------------------------------------------------------------
  (defgeneric SFVec3f (x &optional y z))
  
  (defmethod SFVec3F(x &optional y z)
    (SFVec3F (list x y z)))
  
  (defmethod SFVec3f ((str cl:string) &optional (y NIL) (z NIL))
    (let ((float-list (list<-str str)))
      (apply #'sb-cga:vec float-list)))
  
  (defmethod SFVec3F((val cl:list) &optional (y NIL) (z NIL))
    (apply #'sb-cga:vec (mapcar (lambda (x)
                                  (coerce x 'single-float))
                                val)))
  (defmethod SFVec3F((val cl:vector) &optional (y NIL) (z NIL))
    val)
  
  ;; ----------------------------------------------------------------------------
  (defun SFTranslation+ (a b)
    (sb-cga:vec+ a b))
  
  ;; ----------------------------------------------------------------------------
  (defun SFTranslation<-SFMatrix4F (mat)
    "Returns the translation component from matrix"
    (let ((m03 (sb-cga:mref mat 0 3))
          (m13 (sb-cga:mref mat 1 3))
          (m23 (sb-cga:mref mat 2 3)))
      (SFVec3F m03 m13 m23)))
  
  ;; ----------------------------------------------------------------------------
  (defun SFMatrix4F<-SFTranslation(vec)
    "Makes a transformation matrix from translations"
    (sb-cga:translate vec))
  
  ;; ----------------------------------------------------------------------------
  (defun extract-translation(mat)
    "Returns the translation matrix"
    (let ((m03 (sb-cga:mref mat 0 3))
          (m13 (sb-cga:mref mat 1 3))
          (m23 (sb-cga:mref mat 2 3)))
      (sb-cga:matrix 1.0 0.0 0.0 m03
                     0.0 1.0 0.0 m13
                     0.0 0.0 1.0 m23
                     0.0 0.0 0.0 1.0)))
  
  ;; ----------------------------------------------------------------------------
  (defun extract-rotation (mat)
    "Return the rotation matrix"
    (let ((m00 (sb-cga:mref mat 0 0))
          (m01 (sb-cga:mref mat 0 1))
          (m02 (sb-cga:mref mat 0 2))
          (m10 (sb-cga:mref mat 1 0))
  				(m11 (sb-cga:mref mat 1 1))
  				(m12 (sb-cga:mref mat 1 2))
          (m20 (sb-cga:mref mat 2 0))
  				(m21 (sb-cga:mref mat 2 1))
  				(m22 (sb-cga:mref mat 2 2)))
      (sb-cga:matrix m00 m01 m02 0.0
                     m10 m11 m12 0.0
                     m20 m21 m22 0.0
                     0.0 0.0 0.0 1.0)))
  
  ;; ----------------------------------------------------------------------------
  (defgeneric SFRotation (x &optional y z a))
  
  (defmethod SFRotation(x &optional y z a)
  