anchor.diff:  // *****************************************
   // *****************************************
   
  +[<Struct>]
  +type TextureMeshId =
  +
  +    val MeshId : CompactId
  +
  +    val TextureId : int
  +
  +    val Type : Type
  +
  +    new (meshId, textureId, typ) = { MeshId = meshId; TextureId = textureId; Type = typ }
  +
   type Shader<'Input, 'Output> = Shader of 'Input * 'Output * ShaderProgram
   
   [<Sealed>]
  -type PipelineContext (programCache: ProgramCache) =
  +type SubPipeline (context: PipelineContext, pipeline: Pipeline<unit>) =
  +
  +    let releases = ResizeArray<unit -> unit> ()
  +    let lookup = Dictionary<Type, Dictionary<int, Texture * CompactManager<Mesh * obj>>> ()
  +
  +    member this.Pipeline = pipeline
  +
  +    member this.AddTextureMesh<'T> (texture: Texture, mesh: Mesh, extra: 'T) =
  +        let (_, m) =
  +            match lookup.TryGetValue (typeof<'T>) with
  +            | true, t -> t.[texture.Buffer.Id]
  +            | _ ->
  +                let m = CompactManager<Mesh * obj>.Create (65536)
  +                let textureLookup = Dictionary ()
  +                textureLookup.[texture.Buffer.Id] <- (texture, m)
  +                lookup.[typeof<'T>] <- textureLookup
  +                (texture, m)
  +
  +        let meshId = m.Add (mesh, extra :> obj)
  +        let textureId = texture.Buffer.Id
  +
  +        TextureMeshId (meshId, textureId, typeof<'T>)
  +                              
  +    member this.RemoveTextureMeshById (textureMeshId: TextureMeshId) = 
  +        let (_, m) = lookup.[textureMeshId.Type].[textureMeshId.TextureId]
  +        m.RemoveById (textureMeshId.MeshId)
  +
  +    member this.TryGetLookup<'T> () =
  +        match lookup.TryGetValue (typeof<'T>) with
  +        | true, lookup -> Some lookup
  +        | _ -> None
  +
  +and [<Sealed>] PipelineContext (programCache: ProgramCache) =
       
       let releases = ResizeArray<unit -> unit> ()
       let actions = ResizeArray<unit -> unit> ()
  +    let subPipelines = Dictionary<string, SubPipeline> ()
  +
  +    let subPipelineStack = Stack<SubPipeline> ()
   
       member val ProgramCache = programCache
  +
  +    member this.CurrentSubPipeline =
  +        if subPipelineStack.Count = 0 then None
  +        else Some (subPipelineStack.Peek ())
  +
  +    member this.UseSubPipeline (name) =
  +        match subPipelines.TryGetValue (name) with
  +        | true, subPipeline ->
  +
  +            subPipelineStack.Push (subPipeline)
  +
  +            match subPipeline.Pipeline with
  +            | Pipeline f -> f this
  +
  +            subPipelineStack.Pop () |> ignore
  +
  +        | _ -> ()
   
       member this.AddRelease release =
           releases.Add release
  
positive.code:     {
          Buffer: Texture2DBuffer
      }
  
  // *****************************************
  // *****************************************
  
negative.code:             let f = actions.[i]
              f ()
  
      member val Time = 0.f with get, set
  
      member val View = Matrix4x4.Identity with get, set
  
      member val Projection = Matrix4x4.Identity with get, set
  
  
  
  and Pipeline<'a> = private Pipeline of (PipelineContext -> 'a)
  
  type PipelineBuilder () =
  
  