anchor.diff:          let pset (git : WorkingCopy) (name : string) =
               git.pset (sprintf "%s.%s" (current.Value |> String.concat "") name)
   
  +    module PMod =
  +        let value (m : pmod<'a>) = m.Value
  +
  +    let toV3d (v : V3f) : V3d = V3d.op_Explicit v
  +
       [<AutoOpen>]
       module Interaction =
  -        type Operation = AddPoint of V3f | ClosePolygon | MovePoint of pmod<V3f> * V3f
  +        type Operation = AddPoint of V3f 
  +                       | ClosePolygon 
  +                       | MovePoint of V3f
  +                       | ToggleMoving
   
       module Logics =
   
           open Interaction
  +
  +        let private git = Git.init ()
  +
  +        let unsafeGit = git
   
           let (<~) (p : pmod<'a>) v = PMod.change p v
           
  
positive.code:                 return p
              }
  
          let hoverPosition = Mod.init None
  
          [<AutoOpen>]
          module Controller =
              let appState,workingState = 
                  Scope.scoped "mainScene" (fun () -> 
                      Logics.createScene git, (Scope.pmod git "workingPolygon" [], Scope.empty ())
                  )
              let moving = ref None
              let interact = Logics.interact git (appState,workingState) true
              let interactFast =  Logics.interact git (appState,workingState) false
               
              let polygons = (appState.polygons.CSet :> aset<_>).GetReader()
              win.Mouse.Move.Values.Subscribe(fun (last,current) ->
                  polygons.GetDelta() |> ignore
                  let pick = Camera.pickRay (Mod.force camera) current
                  let nearbyRay = 
                      polygons.Content
                          |> Seq.collect (fun (p : Logics.Polygon) -> 
                              [ for px in p.Value do 
                                  let mutable hit = RayHit3d.MaxRange
                                  let hitD = 
                                      if pick.HitsSphere(V3d.op_Explicit px.Value, 0.1, 0.1, 10.0, &hit) 
                                      then hit.T
                                      else Double.MaxValue
                                  yield p, px, hitD
                              ] )
                          |> Seq.sortBy (fun (_,_,d) -> d)
                          |> Seq.toList
                  match nearbyRay with
                   | [] -> ()
                   | (p,bestPosition,d)::_ -> 
                      transact (fun () -> 
                          if d < Double.MaxValue then
                              Mod.change hoverPosition (Some <| (p, bestPosition, V3d.op_Explicit bestPosition.Value))
                          else Mod.change hoverPosition None
                      )
                  match !moving with
                   | Some point -> 
                      MovePoint (point, camPick |> Mod.force |> Option.get |> V3f.op_Explicit) |> interactFast  
                   | _ -> ()
              ) |> ignore
  
              win.Mouse.Click.Values.Subscribe(fun c ->
                  match c with 
                   | MouseButtons.Left  -> interact (camPick |> Mod.force |> Option.map V3f.op_Explicit |> Option.get |> AddPoint) 
                   | MouseButtons.Right -> interact ClosePolygon 
                   | MouseButtons.Middle -> 
                      match !moving, Mod.force hoverPosition with
                       | None, Some (poly,point,p) -> moving := Some point
                       | Some point, _ -> 
                          interact <| MovePoint (point, camPick |> Mod.force |> Option.get |> V3f.op_Explicit)   
                          moving := None
                       | None, None -> ()
                   | _ -> ()
  
              ) |> ignore
  
  
  
negative.code:                     for p in appState.polygons do
                          let lines = 
                              Mod.custom (fun self -> 
                                  let positions = (p.UnsafeInner :> IMod<_>).GetValue self
                                  let lines = List.foldBack (fun (x:pmod<_>) s -> (x.UnsafeInner :> IMod<_>).GetValue self :: s) positions [] |> List.toArray
                                  Helpers.lineLoopGeometry C4b.White lines
                           )
                          yield Sg.dynamic lines
                  }
  
              let scene =
                  Mod.map2 (lineGeometry C4b.Red) workingState.polygon endPoint 
                      |> Sg.dynamic
                      |> Sg.andAlso (polygonVis |> Sg.set)
  
  