anchor.diff:              |> Option.iter (fun meshComp ->
   
                   match meshComp.State with
  -                | MeshState.ReadyToLoad vertices ->
  +                | MeshState.ReadyToLoad (vertices, uv) ->
                       let vbo = Renderer.makeVbo ()
                       Renderer.bufferVboVector3 vertices (sizeof<Vector3> * vertices.Length) vbo
  -                    meshComp.State <- MeshState.Loaded (vbo)
  +
  +                    let vbo2 = Renderer.makeVbo ()
  +                    Renderer.bufferVbo uv (sizeof<Vector2> * uv.Length) vbo2
  +
  +                    meshComp.State <- 
  +                        MeshState.Loaded
  +                            {
  +                                PositionBufferId = vbo
  +                                PositionBufferLength = vertices.Length
  +
  +                                UvBufferId = vbo2
  +                                UvBufferLength = uv.Length
  +                            }
                   | _ -> ()
   
               )
  
positive.code: open Foom.Ecs
  open Foom.Common.Components
  
  [<RequireQualifiedAccess>]
  type MeshState =
      | ReadyToLoad of vertices: Vector3 []
      | Loaded of bufferId: int
  
  type MeshComponent (vertices: Vector3 []) =
  
      member val State = MeshState.ReadyToLoad (vertices) with get, set
  
      interface IEntityComponent
  
  
negative.code:                     |> Option.iter (fun transformComp ->
                          let mutable invertedTransform = transformComp.Transform
                          Matrix4x4.Invert(transformComp.Transform, &invertedTransform) |> ignore
                          let invertedTransform = invertedTransform |> Matrix4x4.Transpose
  
                          let modelView = (projection * invertedTransform) |> Matrix4x4.Transpose
  
                          Renderer.enableDepth ()
  
                          render modelView entityManager
  
                          Renderer.disableDepth ()
                      )
  