anchor.diff:  // TODO: We could make this instanced.
   type RenderBucket =
       {
  -        Transforms: TransformComponent ResizeArray
  +        GetTransforms: (unit -> Matrix4x4) ResizeArray
           Positions: Vector3ArrayBuffer ResizeArray
           Uvs: Vector2ArrayBuffer ResizeArray
           Colors: Color ResizeArray
  +        RefIndices: Ref<int> ResizeArray
       }
   
   type RenderState =
       {
  +        Deletion: Dictionary<Entity, unit -> unit>
           Lookup: Dictionary<int, Dictionary<int, Texture2DBuffer option * RenderBucket>>
       }
   
  -    member this.Add (programId, textureId, texture, transformComp, position, uv, color) =
  +    member this.Add (ent, programId, textureId, texture, transformComp, position, uv, color) =
           let textureLookup =
               match this.Lookup.TryGetValue (programId) with
               | true, lookup -> lookup
  
positive.code:                         0, None
  
                  let mesh = meshComp.Mesh
                         
                  state.Add (programId, textureId, texture, transformComp, mesh.Position, mesh.Uv, materialComp.Color)
  
              | _ -> ()
          | _ -> ()
  
negative.code: 
                  let bucket =
                      {
                          GetTransforms = ResizeArray ()
                          Positions = ResizeArray ()
                          Uvs = ResizeArray ()
                          Colors = ResizeArray ()
                          RefIndices = ResizeArray ()
                      }
  
                  textureLookup.Add (textureId, (texture, bucket))
  
                  (texture, bucket)
  
          let indexRef = ref bucket.GetTransforms.Count
  
          bucket.GetTransforms.Add transformComp
          bucket.Positions.Add position
          bucket.Uvs.Add uv
          bucket.Colors.Add color
          bucket.RefIndices.Add indexRef
  
          let deletion =
              fun () ->
                  let lastIndexRef = bucket.RefIndices.[bucket.RefIndices.Count - 1]
  
                  let originalIndex = !indexRef
                  let lastIndex = !lastIndexRef
  
                  lastIndexRef := originalIndex
  
                  bucket.GetTransforms.[originalIndex] <- bucket.GetTransforms.[lastIndex]
                  bucket.Positions.[originalIndex] <- bucket.Positions.[lastIndex]
                  bucket.Uvs.[originalIndex] <- bucket.Uvs.[lastIndex]
                  bucket.Colors.[originalIndex] <- bucket.Colors.[lastIndex]
                  bucket.RefIndices.[originalIndex] <- bucket.RefIndices.[lastIndex]
  
                  bucket.GetTransforms.RemoveAt (lastIndex) |> ignore
                  bucket.Positions.RemoveAt (lastIndex) |> ignore
                  bucket.Uvs.RemoveAt (lastIndex) |> ignore
                  bucket.Colors.RemoveAt (lastIndex) |> ignore
                  bucket.RefIndices.RemoveAt (lastIndex) |> ignore
  
          this.Deletion.Add (ent, deletion);
      
      member this.ForEach f =
          this.Lookup
  