anchor.diff:  
   (lpsg:define-uset light (("lightDir" :float-vec4 light-direction :accessor light-direction)))
   
  +(defclass camera-uset-node (lpsg:computation-node lpsg:computation-node-mixin lpsg::source-sink-mixin)
  +  ((uset :accessor uset :initform (make-instance 'camera))))
  +
  +(defmethod lpsg:compute ((node camera-uset-node))
  +  (let ((uset (uset node)))
  +    (setf (camera-matrix uset) (lpsg:input-value node 'view-matrix))
  +    (setf (projection-matrix uset) (lpsg:input-value node 'projection-matrix))
  +    uset))
  +
  +;;; We support orthographic and perspective cameras, so instead of using a complete camera, we
  +;;; build the different parts from mixin classes, and then route their outputs to the
  +;;; camera-uset-node.
  +
  +(defclass partial-view-camera (lpsg-tinker::aimed-camera-mixin lpsg-tinker:view-node-mixin)
  +  ())
  +
  +(defclass partial-ortho-camera (lpsg-tinker::ortho-camera-mixin lpsg-tinker:projection-node-mixin)
  +  ())
  +
  +(defclass partial-fov-camera (lpsg-tinker::fov-camera-mixin lpsg-tinker::projection-node-mixin)
  +  ())
  +
   (defclass cube-window (viewer-window lpsg:renderer)
     ((effect :accessor effect)
      (exposed :accessor exposed :initarg :exposed)
      (projection-type :accessor projection-type :initarg :projection-type)
      (cubes :accessor cubes :initform nil)
  -   (visible-inputs :accessor visible-inputs :initform nil))
  +   (visible-inputs :accessor visible-inputs :initform nil)
  +   (view-camera :accessor view-camera
  +                :initform (make-instance 'partial-view-camera
  +                                         :eye (sb-cga:vec 1.0 1.0 0.0)
  +                                         :target (sb-cga:vec 0.0 0.0 -5.0)
  +                                         :up (sb-cga:vec 0.0 1.0 0.0)))
  +   (ortho-camera :accessor ortho-camera :initform (make-instance 'partial-ortho-camera))
  +   (fov-camera :accessor fov-camera :initform (make-instance 'partial-fov-camera))
  +   (camera-choice :accessor camera-choice)
  +   (camera-selector :accessor camera-selector)
  +   (camera-uset-node :accessor camera-uset-node :initform (make-instance 'camera-uset-node)))
     (:default-initargs :exposed nil :projection-type 'orthographic))
   
  +(defmethod initialize-instance :after ((obj cube-window) &key)
  +  (let ((choice (make-instance 'lpsg::if-then-node))
  +        (selector (make-instance 'lpsg:input-value-node
  +                                 :value (eq (projection-type obj) 'orthographic))))
  +    (setf (lpsg:input choice 'lpsg::then) (lpsg-tinker:projection-matrix-node (ortho-camera obj)))
  +    (setf (lpsg:input choice 'lpsg::else) (lpsg-tinker:projection-matrix-node (fov-camera obj)))
  +    (setf (lpsg:input choice 'if) selector)
  +    (setf (camera-choice obj) choice)
  +    (setf (camera-selector obj) selector)
  +    (setf (lpsg:input (camera-uset-node obj) 'projection-matrix) choice)
  +    (setf (lpsg:input (camera-uset-node obj) 'view-matrix)
  +          (lpsg-tinker::view-matrix-node (view-camera obj)))))
  +
   ;;; Instances of usets
  -(defvar *camera-uset* (make-instance 'camera))
   (defvar *model-uset* (make-instance 'model))
   (defvar *light-uset* (make-instance 'light))
   (defvar *model-uset2* (make-instance 'model))
   
  -(defvar *camera-input* (make-instance 'lpsg:input-value-node :value *camera-uset*))
   (defvar *model-input* (make-instance 'lpsg:input-value-node :value *model-uset*))
   (defvar *light-input* (make-instance 'lpsg:input-value-node :value *light-uset*))
   (defvar *model-input2* (make-instance 'lpsg:input-value-node :value *model-uset2*))
  
positive.code: 
  (defparameter *allocator* (make-instance 'lpsg:simple-allocator))
  
  (defun make-cube (model-input allocator effect)
    (let ((cube (lpsg:make-cube-shape)))
      (setf (lpsg:effect cube) effect)
      (setf (lpsg:input cube 'camera) *camera-input*)
      (setf (lpsg:input cube 'model) model-input)
      (setf (lpsg:input cube 'light) *light-input*)
      ;; Allocate storage  in OpenGL buffer objects for the cube's geometry.  Allocate an array
  
negative.code:     (loop
         for model-input in (list *model-input* *model-input2*)
         for i from 0
         for cube = (make-cube model-input allocator window)
         for cube-visible = (make-instance 'lpsg:input-value-node :value t)
         do (progn
              (setf (lpsg:input cube 'lpsg:visiblep) cube-visible)
  