anchor.diff:  
           | _ -> false
   
  +    member this.WorldPipeline =
  +        Pipeline (fun context ->
  +            context.AddAction (fun () ->
  +                for i = 0 to this.cameraDepths.Length - 1 do
  +
  +                    let cameras = this.cameraDepths.[i]
  +
  +                    for i = 0 to cameras.Count - 1 do
  +
  +                        let camera = cameras.[i]
  +
  +                        if camera.clearFlags.HasFlag (CameraClearFlags.Depth) then
  +                            Backend.clearDepth ()
  +
  +                        if camera.clearFlags.HasFlag (CameraClearFlags.Color) then
  +                            Backend.clearColor ()
  +
  +                        if camera.clearFlags.HasFlag (CameraClearFlags.Stencil) then
  +                            Backend.clearStencil ()
  +
  +                        for i = 0 to this.layerManager.Count - 1 do
  +                            let mask =
  +                                match i with
  +                                | 0 -> CameraLayerFlags.Layer0
  +                                | 1 -> CameraLayerFlags.Layer1
  +                                | 2 -> CameraLayerFlags.Layer2
  +                                | 3 -> CameraLayerFlags.Layer3
  +                                | 4 -> CameraLayerFlags.Layer4
  +                                | 5 -> CameraLayerFlags.Layer5
  +                                | 6 -> CameraLayerFlags.Layer6
  +                                | _ -> CameraLayerFlags.None
  +
  +                            if camera.layerFlags.HasFlag (mask) then
  +                                this.layerManager.TryFindById (CompactId (i, 1u))
  +                                |> Option.iter (fun renderLayer ->
  +
  +                                    renderLayer.textureMeshes
  +                                    |> Seq.iter (fun pair ->
  +                                        let shaderId = pair.Key
  +                                        let textureLookup = pair.Value
  +
  +                                        let shader, f = this.shaders.[shaderId]
  +
  +                                        Backend.useProgram shader.programId
  +
  +                                        textureLookup
  +                                        |> Seq.iter (fun pair ->
  +                                            let texture, bucket = pair.Value
  +                                            f this.time camera.view camera.projection texture bucket
  +                                            shader.Unbind ()
  +                                        )
  +
  +                                        Backend.useProgram 0
  +                                    )
  +                                )
  +            )
  +        )
  +
       member this.Draw (time: float32) =
  +        this.time <- time
   
           Backend.enableDepth ()
   
  -        this.finalRenderTexture.TryBufferData () |> ignore
  -        this.finalRenderTexture.Bind ()
  -
  -        for i = 0 to this.cameraDepths.Length - 1 do
  -
  -            let cameras = this.cameraDepths.[i]
  -
  -            for i = 0 to cameras.Count - 1 do
  -
  -                let camera = cameras.[i]
  -
  -                //renderCamera.renderTexture.TryBufferData () |> ignore
  -
  -                //renderCamera.renderTexture.Bind ()
  -
  -                if camera.clearFlags.HasFlag (CameraClearFlags.Depth) then
  -                    Backend.clearDepth ()
  -
  -                if camera.clearFlags.HasFlag (CameraClearFlags.Color) then
  -                    Backend.clearColor ()
  -
  -                if camera.clearFlags.HasFlag (CameraClearFlags.Stencil) then
  -                    Backend.clearStencil ()
  -
  -                for i = 0 to this.layerManager.Count - 1 do
  -                    let mask =
  -                        match i with
  -                        | 0 -> CameraLayerFlags.Layer0
  -                        | 1 -> CameraLayerFlags.Layer1
  -                        | 2 -> CameraLayerFlags.Layer2
  -                        | 3 -> CameraLayerFlags.Layer3
  -                        | 4 -> CameraLayerFlags.Layer4
  -                        | 5 -> CameraLayerFlags.Layer5
  -                        | 6 -> CameraLayerFlags.Layer6
  -                        | _ -> CameraLayerFlags.None
  -
  -                    if camera.layerFlags.HasFlag (mask) then
  -                        this.layerManager.TryFindById (CompactId (i, 1u))
  -                        |> Option.iter (fun renderLayer ->
  -
  -                            renderLayer.textureMeshes
  -                            |> Seq.iter (fun pair ->
  -                                let shaderId = pair.Key
  -                                let textureLookup = pair.Value
  -
  -                                let shader, f = this.shaders.[shaderId]
  -
  -                                Backend.useProgram shader.programId
  -
  -                                textureLookup
  -                                |> Seq.iter (fun pair ->
  -                                    let texture, bucket = pair.Value
  -                                    f time camera.view camera.projection texture bucket
  -                                    shader.Unbind ()
  -                                )
  -
  -                                Backend.useProgram 0
  -                            )
  -                        )
  -
  -                //renderCamera.renderTexture.Unbind ()
  -
  -        //Backend.disableStencilTest ()
  -        this.finalRenderTexture.Unbind ()
  -
  -
  -        Backend.clear ()
  -
  -        Backend.useProgram this.finalShaderProgram.programId
  -
  -
  -        this.finalPosition.Set this.finalPositionBuffer
  -        this.finalTexture.Set this.finalRenderTexture
  -        this.finalTime.Set time
  -
  -        this.finalShaderProgram.Run RenderPass.Depth
  -        this.finalShaderProgram.Unbind ()
  -
  -        Backend.useProgram 0
  +        this.finalPipeline.Run ()
   
           Backend.disableDepth ()
   
  
positive.code:         let maxCameras = 100
          let maxCameraLayers = 7
  
          let shaderProgram = ShaderProgram.Load("Fullscreen")
  
          let vertices =
              [|
  
negative.code:                 context.AddAction (fun () ->
                      renderTexture.TryBufferData () |> ignore
                      renderTexture.Bind ()
                  )            
                  
                  match p with
  