anchor.diff:  
                   let deltas = ConcurrentDeltaQueue.ofASet content
   
  -                let printer =
  -                    async {
  -                        while true do
  -                            do! Async.Sleep 5000
  -                            Log.start "LoD"
  -                            for i in 0..levelCounts.Length-1 do
  -                                let cnt = levelCounts.[i]
  -                                if cnt <> 0 then
  -                                    Log.line "level %d: %d" i cnt
  -                            Log.stop()
  -                    }
  +//                let printer =
  +//                    async {
  +//                        while true do
  +//                            do! Async.Sleep 5000
  +//                            Log.start "LoD"
  +//                            for i in 0..levelCounts.Length-1 do
  +//                                let cnt = levelCounts.[i]
  +//                                if cnt <> 0 then
  +//                                    Log.line "level %d: %d" i cnt
  +//                            Log.stop()
  +//                    }
   
                   let runner =
                       async {
  
positive.code:         let inline private height (plane : V4d) (b : Box3d) =
              plane.Dot(maxDir plane.XYZ b)
  
  
  
          type Box3d with
              member x.IntersectsFrustumGL (viewProj : M44d) =
                  let r0 = viewProj.R0
                  let r1 = viewProj.R1
                  let r2 = viewProj.R2
                  let r3 = viewProj.R3
  
                  height (r3 + r0) x >= 0.0 &&
                  height (r3 - r0) x >= 0.0 &&
                  height (r3 + r1) x >= 0.0 &&
                  height (r3 - r1) x >= 0.0 &&
                  height (r3 + r2) x >= 0.0 &&
                  height (r3 - r2) x >= 0.0 
                  
  
  
  
  
          type ILodData with
              member x.Rasterize(view : Trafo3d, projTrafo : Trafo3d, wantedNearPlaneDistance : float) =
                  let viewProj = view * projTrafo
                  let camLocation = view.GetViewPosition()
  
                  let result = HashSet<LodDataNode>()
  
                  let frustum = Frustum.ofTrafo projTrafo
  
                  let hull = ViewProj.toFastHull3d viewProj
  
  
                  x.Traverse(fun node ->
                      if hull.Intersects(node.bounds) then
                          if node.inner then
                              let bounds = node.bounds
  
  
  
                              let depthRange =
                                  bounds.ComputeCorners()
                                      |> Array.map view.Forward.TransformPos
                                      |> Array.map (fun v -> -v.Z)
                                      |> Range1d
  //
  //                            if depthRange.Max < frustum.near || depthRange.Min > frustum.far then
  //                                false
  //                            else
                              let depthRange = Range1d(clamp frustum.near frustum.far depthRange.Min, clamp frustum.near frustum.far depthRange.Max)
                              let projAvgDistance =
                                  abs (node.granularity / depthRange.Min)
  
                              result.Add node |> ignore
                              if projAvgDistance > wantedNearPlaneDistance then
                                  true
  
negative.code: 
                                      | _ ->
                                          ()
                              
                              do! Async.Sleep node.Config.pruneInterval
                      }
  
                  Async.StartAsTask(runner, cancellationToken = cancel.Token) |> ignore
                  //Async.StartAsTask(printer, cancellationToken = cancel.Token) |> ignore
                  Async.StartAsTask(prune, cancellationToken = cancel.Token) |> ignore
  
                  { new IDisposable with member x.Dispose() = () }
  