anchor.diff:                 (push mesh
                        (gethash (scene-mesh-file mesh) mesh-files))))
         ;; collect mesh files
  -      (do-scene-graph-frames (frame scene-graph)
  -        (loop
  -           for v in (scene-frame-visual frame)
  -           for g = (scene-visual-geometry v)
  -           when (and g (scene-mesh-p g))
  -           do (resolve-mesh g))))
  +      (do-scene-graph-visuals ((frame-name visual) scene-graph)
  +        (declare (ignore frame-name))
  +        (let ((g (scene-visual-geometry visual)))
  +          (when (and g (scene-mesh-p g))
  +            (resolve-mesh g)))))
       (maphash (lambda (mesh-file mesh-nodes)
                  (format *standard-output* "~&Converting ~A..." mesh-file)
                  (let* ((dom (dom-load mesh-file))
  
positive.code:           (tf (scene-frame-prismatic-rotation frame)
                (g* config axis))))))))
  
  (defun scene-graph-tf-relative (scene-graph configuration-map
                                  &key (default-configuration 0d0))
    (fold-scene-graph-frames (lambda (hash frame)
                               (setf (gethash (scene-frame-name frame) hash)
                                     (scene-frame-tf-relative frame configuration-map default-configuration))
                               hash)
                             (make-hash-table :test #'equal)
                             scene-graph))
  
  (defun scene-graph-tf-absolute (scene-graph configuration-map
                                  &key (default-configuration 0d0))
    (let ((tf-relative (scene-graph-tf-relative scene-graph configuration-map
                                                :default-configuration default-configuration)))
      (labels ((contains (hash frame)
                 (nth-value 1 (gethash (scene-frame-name frame) hash)))
               (rec (tf-abs frame)
                 (unless (contains tf-abs frame)
                   (let ((parent (scene-frame-parent frame))
                         (name (scene-frame-name frame)))
                     (if parent
                         (progn
                           (rec tf-abs (scene-graph-lookup scene-graph parent))
                           (setf (gethash name tf-abs)
                                 (normalize (g* (gethash parent tf-abs)
                                                (gethash name tf-relative)))))
                         (setf (gethash name tf-abs)
                               (gethash name tf-relative)))))
                 tf-abs))
        (fold-scene-graph-frames #'rec (make-hash-table :test #'equal) scene-graph))))
  
  
  (defun scene-graph-configurations (scene-graph)
  
negative.code:              (visual (vis name)
                 (thing (scene-visual-pov vis (pov-transform* (pov-value (tf name)))))))
        ;; push frame geometry
        (do-scene-graph-visuals ((name vis) scene-graph)
          (visual vis name))
        ;; push frame transforms
        (when configuration-map
          (map nil #'thing
  