anchor.diff:  
       let camera = Mod.map2 Camera.create cameraView frustum
   
  -    let mutable model = { hovered = None; lastClick = None; trafo = Trafo3d.Identity }
       let scene = Mod.init (view model)
       let sg = scene |> Mod.map toSg |> Sg.dynamic
   
  
positive.code:         match pick ray (Mod.force scene) with
              | Some ((d,f)::_) -> 
                  for msg in f do
                      match msg Move with
                          | Some r -> model <- update model r
                          | _ -> ()
              | _ -> 
                  model <- update model Cleared
          transact (fun _ -> scene.Value <- view model) 
      ) |> ignore
  
      win.Mouse.Down.Values.Subscribe(fun p -> 
          let ray = win.Mouse.Position |> Mod.force |> Camera.pickRay (camera |> Mod.force)
          match pick ray (Mod.force scene) with
              | Some ((d,f)::_) -> 
                  for msg in f do
                      match msg Down with
                          | Some r -> 
                              printfn "%A" r
                              model <- update model r
                          | _ -> ()
              | _ -> 
                  model <- update model Cleared
          transact (fun _ -> scene.Value <- view model) 
      ) |> ignore
  
      let s = 
          Interactive.Window.Runtime.PrepareEffect [
                  DefaultSurfaces.trafo |> toEffect       
                  DefaultSurfaces.vertexColor |> toEffect 
          ] 
  
      let fullScene =
  //        sg |> Sg.effect [
  //                DefaultSurfaces.trafo |> toEffect       
  //                DefaultSurfaces.vertexColor |> toEffect 
  //                ]
            sg 
              |> Sg.andAlso (Sg.box' C4b.White Box3d.Unit |> Sg.translate 10000.0 10000.0 1000.0)
              |> Sg.surface( s :> ISurface |> Mod.constant)
  
negative.code:                     if r.HitsSphere(s2,s.Radius,0.0,Double.PositiveInfinity, &ha) then
                          [ha.T, action]
                      else []
                  | Render(action,Cone(center,dir,height,radius)) | Render(action,Cylinder(center,dir,height,radius)) -> 
                      let cylinder = Cylinder3d(state.trafo.Forward.TransformPos center,state.trafo.Forward.TransformPos (center+dir*height),radius)
                      let mutable ha = RayHit3d.MaxRange
                      if r.Hits(cylinder,0.0,Double.MaxValue,&ha) then
                          [ha.T, action]
                      else []
                  | _ -> failwith ""
          match s |> go { trafo = Trafo3d.Identity; color = C4b.White } with
              | [] -> None
              | xs -> xs |>  List.sortBy fst |> Some
  
  module Controllers = 
  
      open ImmutableSceneGraph
  
      FsiSetup.initFsi (Path.combine [__SOURCE_DIRECTORY__; ".."; ".."; ".."; ".."; "bin";"Debug";"Examples.exe"])
  
      let win = Interactive.Window
  
      type Axis = X | Y | Z
  
      [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
      module Axis =
          let dir = function | X -> V3d.XAxis | Y -> V3d.YAxis | Z -> V3d.ZAxis
          let moveAxis = function
              | X -> Plane3d.YPlane
              | Y -> Plane3d.ZPlane
              | Z -> Plane3d.XPlane
  
      type Msg = 
          // hover overs
          | Hover           of Axis * V3d
          | NoHit       
          | MoveRay         of Ray3d
          // translations    
          | Translate       of Axis * V3d
          | EndTranslation 
  
      let hover      = curry Hover
      let translate_ = curry Translate
      let on  (p : Kind -> bool) (r : V3d -> 'msg) (k : Kind) = if p k then Some (r (Event.position k)) else None
  
      type Model = {
          hovered           : Option<Axis>
          activeTranslation : Option<Plane3d * V3d>
          trafo             : Trafo3d
      }
  
  
      let mutable model = { hovered = None; activeTranslation = None; trafo = Trafo3d.Identity }
  
      let update (m : Model) (a : Msg) =
          match a, m.activeTranslation with
              | NoHit, _             ->  { m with hovered = None; }
              | Hover (v,_), _       ->  { m with hovered = Some v}
              | Translate (dir,s), _ -> { m with activeTranslation = Some (Axis.moveAxis dir, s) }
              | EndTranslation, _    -> { m with activeTranslation = None; trafo = Trafo3d.Identity }
              | MoveRay r, Some (t,start) -> 
                  let mutable ha = RayHit3d.MaxRange
                  if r.HitsPlane(t,0.0,Double.MaxValue,&ha) then
                      { m with trafo = Trafo3d.Translation (ha.Point - start) }
                  else m
              | MoveRay r, None -> m
  
  
      let view (m : Model) =
          let arrow dir = Cone(V3d.OOO,dir,0.3,0.1)
  
          let ifHit (a : Axis) (selection : C4b) (defaultColor : C4b) =
              match m.hovered with
                  | Some v when v = a -> selection
                  | _ -> defaultColor
              
          transformed m.trafo [
                  translate 1.0 0.0 0.0 [
                      [ arrow V3d.IOO |> render [on Event.move (hover X); on Event.down (translate_ X)] ] 
                          |> colored (ifHit X C4b.White C4b.DarkRed)
                  ]
                  translate 0.0 1.0 0.0 [
                      [ arrow V3d.OIO |> render [on Event.move (hover Y); on Event.down (translate_ Y)] ] 
                          |> colored (ifHit Y C4b.White C4b.DarkBlue)
                  ]
                  translate 0.0 0.0 1.0 [
                      [ arrow V3d.OOI |> render [on Event.move (hover Z); on Event.down (translate_ Z)] ] 
                          |> colored (ifHit Z C4b.White C4b.DarkGreen)
                  ]
  
                  [ cylinder V3d.OOO V3d.IOO 1.0 0.05 |> render [ on Event.move (hover X); on Event.down (translate_ X) ] ] |> colored (ifHit X C4b.White C4b.DarkRed)
                  [ cylinder V3d.OOO V3d.OIO 1.0 0.05 |> render [ on Event.move (hover Y); on Event.down (translate_ Y) ] ] |> colored (ifHit Y C4b.White C4b.DarkBlue)
                  [ cylinder V3d.OOO V3d.OOI 1.0 0.05 |> render [ on Event.move (hover Z); on Event.down (translate_ Z) ] ] |> colored (ifHit Z C4b.White C4b.DarkGreen)
                  
                  translate 0.0 0.0 0.0 [
                      [Sphere3d(V3d.OOO,0.1) |> Sphere |> render Pick.ignore] |> colored C4b.Gray
                  ]
          ]
  
      let cameraView = 
          CameraView.lookAt (V3d(6.0, 6.0, 6.0)) V3d.Zero V3d.OOI
              |> Mod.constant
              //|> DefaultCameraController.control win.Mouse win.Keyboard win.Time
  
      let frustum = 
          win.Sizes 
  