anchor.diff:  
               let render =
                   {
  -                    ShaderProgramId = shader.programId
  +                    ShaderProgramId = shaderProgram.programId
                       TextureId = material.Texture.Buffer.Id
                       IdRef = idRef
                   }
  
positive.code: type VertexAttribute<'T> =
      {
          name: string
          mutable value: 'T
          mutable location: int
      }
  
      member this.Set value = this.value <- value
  
  type Shader =
      {
          programId: int
          mutable isInitialized: bool
  
negative.code:     member this.CreateTexture2DBuffer (bmp) =
          Texture2DBuffer (bmp)
  
      member this.CreateShader (vertexShader, fragmentShader, f: ShaderProgram -> (Matrix4x4 -> Matrix4x4 -> unit)) =
          let shaderProgram =
              Renderer.loadShaders vertexShader fragmentShader
              |> ShaderProgram.Create
  
          this.Shaders.[shaderProgram.programId] <- f shaderProgram
  
          {
              ShaderProgram = shaderProgram
          }
  
      // TextureMesh shader
      member this.CreateShader (vertexShader, fragmentShader) =
          this.CreateShader (vertexShader, fragmentShader,
  
              fun shaderProgram ->
                  let in_position = shaderProgram.CreateVertexAttributeVector3 ("position")
                  let in_uv = shaderProgram.CreateVertexAttributeVector2 ("in_uv")
                  let in_texture = shaderProgram.CreateUniformTexture2D ("uni_texture")
                  let uni_view = shaderProgram.CreateUniformMatrix4x4 ("uni_view")
                  let uni_projection = shaderProgram.CreateUniformMatrix4x4 ("uni_projection")
  
                  fun view projection ->
                      this.Lookup
                      |> Seq.iter (fun pair ->
                          let programId = pair.Key
                          let textureLookup = pair.Value
  
                          Renderer.useProgram programId
  
                          textureLookup
                          |> Seq.iter (fun pair ->
                              let textureId = pair.Key
                              let (texture, bucket) = pair.Value
  
                              let count = bucket.Meshes.Count
  
                              for i = 0 to count - 1 do
  
                                  let mesh = bucket.Meshes.[i]
  
                                  in_position.Set     mesh.Position
                                  in_uv.Set           mesh.Uv
                                  in_texture.Set      texture.Buffer
                                  uni_view.Set        view
                                  uni_projection.Set  projection
  
                                  let color = mesh.Color
                                  let center = mesh.Center
  
                                  let programId = shaderProgram.programId
  
                                  color.TryBufferData () |> ignore
                                  center.TryBufferData () |> ignore
  
                                  color.Bind ()
                                  Renderer.bindColor programId
  
                                  center.Bind ()
                                  Renderer.bindCenter programId
  
                                  shaderProgram.Run ()
                          )
                      ) 
  
          )
  
      member this.CreateTexture (bmp) =
          {
  