anchor.diff:                  else V2i.Zero
               ) w s
   
  +        //we combine the separate axes into one variable, a (normalized) movement vector
           let move = Mod.map2 (+) moveX moveY
   
  -        adaptive {
  +        //an adaptive computation expression is created to make working in the incremental 'realm' easier
  +        adaptive {
  +            
  +            //let! unwraps an IMod so we can work with the underlying value.
               let! m = move
  +
  +            //If a key has been pressed
               if m <> V2i.Zero then
  -                return time |> Mod.stepTime (fun t dt (cam : CameraView)  ->
  -                    //printfn "%Ams" dt.TotalMilliseconds
  +                // map the current time to a delta time, then apply it to a function
  +                return time 
  +                |> Mod.stepTime (fun t dt (cam : CameraView)  ->
  +                    
  +                    //apply our movement vector relative to the direction the camera is facing
                       let direction = float m.X * cam.Right + float m.Y * cam.Forward
  +                    
  +                    // 1.2 is the default speed
                       let delta = 1.2 * dt.TotalSeconds * direction
   
  +                    //update camera location
                       cam.WithLocation(cam.Location + delta)
                   )
  -            else
  -                return AdaptiveFunc.Identity
  -        }
  -
  -    let controlLookAround (m : IMouse) =
  -        let down = m.IsDown(MouseButtons.Left)
  -        let location = m.Position |> Mod.map (fun pp -> pp.Position)
  +            // else do nothing
  +            else
  +                return AdaptiveFunc.Identity
  +        }
  +
  +    /// <summary> Gives a camera look controls. 
  +    /// Left mouse button controls the functionality </summary>
  +    /// <param name="mouse"> the mouse inputs (this is often pulled from the parent window)</param>
  +    /// <returns>An incremental function that takes a CameraView</returns>
  +    let controlLookAround (mouse : IMouse) =
  +        let down = mouse.IsDown(MouseButtons.Left)
  +        let location = mouse.Position |> Mod.map (fun pp -> pp.Position)
   
           adaptive {
               let! d = down
  
positive.code:             else
                  return AdaptiveFunc.Identity
          } |> Mod.onPush
  
      let controlPanWithSpeed (speed : ModRef<float>) (m : IMouse) =
          let down = m.IsDown(MouseButtons.Middle)
          let location = m.Position |> Mod.map (fun pp -> pp.Position)
  
          adaptive {
              let! d = down
  
negative.code:             controllScrollWithSpeed speed mouse time
          ]
  
      /// <summary> Implement common control functions for movement, looking, panning, and zooming 
      /// for a given camera. also adds the ability to adjust movement speed.
      /// Default controls use PageUp and PageDown.</summary>
      /// <param name="initialSpeed"> the initial rate at which all movement occurs</param>
      /// <param name="mouse"> the mouse inputs (this is often pulled from the parent window)</param>
      /// <param name="keyboard"> the keyboard inputs (this is often pulled from the parent window)</param>
      /// <param name="time"> the relative time (this is often pulled from the parent window)</param>
      /// <param name="camera"> the initial state of the camera</param>
      /// <returns>An incremental function that takes a CameraView</returns>
      let controlExt (initialSpeed : float ) (mouse : IMouse) (keyboard : IKeyboard) (time : IMod<DateTime>) (cam : CameraView) : IMod<CameraView> =
          let speed = Mod.init initialSpeed
  
  