nsf/voxels.fs

## voxels.fs
namespace NG.FS.VoxelMap.Components

open System
open System.IO
open System.Diagnostics
open System.Collections.Generic
open NG.FS.VoxelMap.Common
open NG.FS.Math
open NG.FS.Coroutines
open NG.FS.ArrayUtils
open NG

type RequestType =
    | Read
    | Write

type Operation =
    | Grab
    | Release

type Request = {
    Type      : RequestType
    Location  : Vec2i
    Size      : Vec2i
    Data      : C.MapChunkColumn[,]
}

type DeferredRequest = {
    Request   : Request
    Coroutine : Coroutine
}

[<Struct>]
type ChunkColumnInfo =
    val mutable Readers : int
    member this.HasWriter = this.Readers = -1
    member this.HasReaders = this.Readers > 0

// Location is in storage chunks
type StorageChunk (location : Vec2i) =
    let storageChunk = C.MapStorageChunk.New()
    let fileName = sprintf "%08X_%08X.ngc" location.X location.Y

    member val ColumnsInfo = createArray2D STORAGE_CHUNK_SIZE.XY (ChunkColumnInfo(Readers=0))

    member sc.Save (dir : string) = routine {
        storageChunk.Serialize()
        do! coroutine_p(Type = IO) { storageChunk.SaveData(Path.Combine(dir, fileName)) }
    }

    member sc.Load (dir : string) = routine {
        let! loaded = coroutine_p(Type = IO) { return storageChunk.LoadData(Path.Combine(dir, fileName)) }
        if loaded then
            storageChunk.Deserialize()
        return loaded
    }

    member sc.Generate () = routine {
        let baseLoc = storageChunkLocationToChunkColumnLocation location
        let generateColumn (loc : Vec2i) = coroutine {
            C.MapGenerator.GenerateColumn(storageChunk.Column(loc), baseLoc + loc)
        }
        do! initFlatArray2D STORAGE_CHUNK_SIZE.XY generateColumn
    }

    member sc.Column (p : Vec2i) = storageChunk.Column(p)

    member sc.Dispose () = (sc :> IDisposable).Dispose()
    interface IDisposable with
        member sc.Dispose () = storageChunk.Dispose()

type Storage (dir : string) =
    let storageChunks = Dictionary<Vec2i, StorageChunk option>()
    let deferredRequests = List<DeferredRequest>()
    let mutex = Mutex()

    let addSelfToDeferredRequests r =
        let c = Scheduler.CurrentCoroutine()
        let dr = { Request = r; Coroutine = c }
        deferredRequests.Add(dr)

    let applyRequest (r : Request) (op : Operation) =
        let mutator =
            match op with
            | Grab ->
                match r.Type with
                | Read -> fun (info : ChunkColumnInfo) ->
                    ChunkColumnInfo(Readers = info.Readers+1)
                | Write -> fun (info : ChunkColumnInfo) ->
                    ChunkColumnInfo(Readers = -1)
            | Release ->
                match r.Type with
                | Read -> fun (info : ChunkColumnInfo) ->
                    ChunkColumnInfo(Readers = info.Readers-1)
                | Write -> fun (info : ChunkColumnInfo) ->
                    ChunkColumnInfo(Readers = 0)

        seqBase2D r.Location r.Size |> Seq.iter (fun p ->
            // storage chunk location for this chunk column
            let scloc = chunkColumnLocationToStorageChunkLocation p
            // chunk column location relative to storage chunk (that is location inside the storage chunk)
            let scp = p - (storageChunkLocationToChunkColumnLocation scloc)
            match storageChunks.[scloc] with
            | Some sc ->
                sc.ColumnsInfo.[scp.Y, scp.X] <- mutator sc.ColumnsInfo.[scp.Y, scp.X]
            | None -> failwith "never happens")

    // The last parameter is used to queue loading of a storage chunk (given location).
    // Usually you need to do so when request arrives, but not for deferred requests.
    // Also it breaks cyclic dependency.
    let trySatisfyRequest (r : Request) (queueStorageChunk : Vec2i -> unit) =
        let result = ref true
        seqBase2D r.Location r.Size |> Seq.iter (fun p ->
            // storage chunk location for this chunk column
            let scloc = chunkColumnLocationToStorageChunkLocation p
            // chunk column location relative to storage chunk (that is location inside the storage chunk)
            let scp = p - (storageChunkLocationToChunkColumnLocation scloc)
            // chunk column location relative to result array
            let rp = p - r.Location
            match storageChunks.TryGetValue(scloc) with
            | true, Some sc ->
                let info = sc.ColumnsInfo.[scp.Y, scp.X]
                match r.Type with
                | Read ->
                    if info.HasWriter then
                        result := false
                | Write ->
                    if info.HasReaders then
                        result := false
                r.Data.[rp.Y, rp.X] <- sc.Column scp
            | true, None ->
                result := false
            | false, _ ->
                // Here we should also spawn the loading coroutine
                result := false
                storageChunks.[scloc] <- None
                queueStorageChunk scloc
        )

        if !result then
            applyRequest r Grab

        !result

    let trySatisfyDeferredRequest (dr : DeferredRequest) =
        if trySatisfyRequest dr.Request ignore then
            Scheduler.Go dr.Coroutine
            true
        else
            false

    let trySatisfyDeferredRequests () =
        deferredRequests.RemoveAll (Predicate trySatisfyDeferredRequest) |> ignore

    // 1. Does loading/generation.
    // 2. Locks the mutex.
    // 3. Writes result to storageChunks dict
    // Note: caller should write "None" to storageChunks before executing this coroutine.
    let loadOrGenerateStorageChunk (loc : Vec2i) = coroutine {
        let sc = new StorageChunk(loc)
        let! loaded = sc.Load(dir)
        if not loaded then
            do! sc.Generate()

        do! lockMutex(mutex)
        storageChunks.[loc] <- Some sc
        trySatisfyDeferredRequests()
    }

    let queueStorageChunk (loc : Vec2i) =
        Scheduler.Go (loadOrGenerateStorageChunk loc)

    // Location and size is in chunk columns
    member this.AcquireChunkColumns (r : RequestType) (loc : Vec2i) (size : Vec2i) = coroutine {
        do! lockMutex(mutex)

        let req = { Type = r; Location = loc; Size = size; Data = zeroCreateArray2D size }
        if not (trySatisfyRequest req queueStorageChunk) then
            // If request cannot be satisfied immediately, we will queue ourselves
            // and sleep. Eventually somebody will satisfy it.
            addSelfToDeferredRequests req
            do! sleep()

        return req
    }

    member this.ReleaseChunkColumns (r : Request) = coroutine {
        do! lockMutex(mutex)
        applyRequest r Release
        trySatisfyDeferredRequests()
    }

type ChunkMeshType =
    | GraphicsOnly
    | PhysicsAndGraphics

[<AllowNullLiteral>]
type ChunkMesh (t : ChunkMeshType) =
    let mutable refCount = 1
    let chunkMesh = C.MapChunkMesh.New()

    member this.RefCount = refCount
    member this.ChunkMesh = chunkMesh
    member this.VerticesCount = chunkMesh.VerticesCount()
    member val Type = t
    member val VerticesOffset = 0 with get, set

    member this.Dispose () = (this :> IDisposable).Dispose()
    interface IDisposable with
        member this.Dispose () =
            refCount <- refCount - 1
            if refCount = 0 then
                chunkMesh.Dispose()

    member this.Mesh (columns : C.MapChunkColumn[,]) (z : int) =
        use a = C.MapChunkColumnArray.New(4)
        a.SetNth(0, columns.[0, 0])
        a.SetNth(1, columns.[0, 1])
        a.SetNth(2, columns.[1, 0])
        a.SetNth(3, columns.[1, 1])
        chunkMesh.Mesh(a, z)

    member this.Grab () =
        refCount <- refCount + 1
        this

type Segment (segment : C.MapSegment, location : Vec2i, storage : Storage) =
    let mutable current = zeroCreateArray3D<ChunkMesh> SEGMENT_SIZE
    let mutable next = zeroCreateArray3D<ChunkMesh> SEGMENT_SIZE
    let mutable lastPlayerLocation = Vec3i Int32.MaxValue // in chunks

    let getChunkMeshType (player : Vec3i) (p : Vec3i) =
        let d = Vec3i.ChebyshevDistance player p
        if d <= 2 then PhysicsAndGraphics else GraphicsOnly

    let swap () =
        let tmp = current
        current <- next
        next <- tmp

        next |> Array3D.iter (fun cm -> if not (isNull cm) then cm.Dispose())
        fillArray3D next null

    let chunkMeshUpload (cm : ChunkMesh) = coroutine {
        let mutable msg = C.Messages.MapChunkMeshAppend.New()
        msg.Segment <- segment
        msg.ChunkMesh <- cm.ChunkMesh
        do! msg

        cm.VerticesOffset <- msg.OutVerticesOffset
        msg.Dispose()
    }

    let chunkMeshBuildAndUpload (ap : Vec3i) (cm : ChunkMesh) = coroutine {
        let! r = storage.AcquireChunkColumns Read (ap.XY - Vec2i 1) (Vec2i 2)
        cm.Mesh r.Data ap.Z
        do! storage.ReleaseChunkColumns r

        if cm.VerticesCount <> 0 then
            let mutable msg = C.Messages.MapChunkMeshAppend.New()
            msg.Segment <- segment
            msg.ChunkMesh <- cm.ChunkMesh
            do! msg

            cm.VerticesOffset <- msg.OutVerticesOffset
            msg.Dispose()
        else
            cm.VerticesOffset <- 0
    }

    member private this.RebuildSegment (min : Vec3i) (max : Vec3i) = routine {
        let baseLoc = segmentLocationToChunkLocation location
        let buildAndUpload =
            seqBase3D (Vec3i 0) SEGMENT_SIZE
            |> Seq.filter (fun p -> min .<= p && p .<= max)
            |> Seq.choose (fun p ->
                let ap = baseLoc + p
                let cmtype = getChunkMeshType lastPlayerLocation ap
                let cm = current.[p.Z, p.Y, p.X]
                if not (isNull cm) && cm.Type = cmtype then
                    next.[p.Z, p.Y, p.X] <- cm.Grab()
                    None
                else
                    let cm = new ChunkMesh(cmtype)
                    next.[p.Z, p.Y, p.X] <- cm
                    Some (chunkMeshBuildAndUpload ap cm)
            )

        let upload =
            seqBase3D (Vec3i 0) SEGMENT_SIZE
            |> Seq.filter (fun p -> let cm = next.[p.Z, p.Y, p.X] in not (isNull cm) && cm.RefCount = 2)
            |> Seq.map (fun p -> chunkMeshUpload next.[p.Z, p.Y, p.X])

        do! upload
        do! buildAndUpload

        seqBase3D (Vec3i 0) SEGMENT_SIZE
        |> Seq.iter (fun p ->
            let cm = next.[p.Z, p.Y, p.X]
            if not (isNull cm) && cm.VerticesCount <> 0 then
                segment.AppendInfo(p, cm.VerticesOffset, cm.VerticesCount)
        )

        let mutable msg = C.Messages.MapSegmentSwap.New()
        msg.Segment <- segment
        do! sendMessageAndDispose msg

        swap()
    }

    member this.Segment = segment
    member this.Location = location

    // all Vec3i parameters are in chunks
    member this.RebuildSegmentMaybe (player : Vec3i) (min : Vec3i) (max : Vec3i) = coroutine {
        if lastPlayerLocation <> player then
            lastPlayerLocation <- player
            do! this.RebuildSegment min max
    }

    member this.Dispose () = (this :> IDisposable).Dispose()
    interface IDisposable with
        member this.Dispose () =
            segment.Dispose()

type Map (storage : Storage) =
    let map = C.Map.New();
    let segments = Dictionary<Vec2i, Segment>();
    let viewDistance = 400
    let mutex = Mutex()
    let mutable lastPlayerLocation = Vec3i Int32.MaxValue // in chunks

    member private this.CreateSegment (loc : Vec2i) = coroutine {
        let mutable msg = C.Messages.MapSegmentNew.New()
        msg.Location <- loc
        do! msg

        let s = new Segment(msg.OutSegment, loc, storage)
        msg.Dispose()
        return s
    }

    member private this.Rebuild () = routine {
        let viewChunks = viewDistance / CHUNK_SIZE_I
        let visRange = Vec3i(viewChunks * 2, viewChunks * 2, STORAGE_CHUNK_SIZE.Z)
        let halfVisRange = visRange / Vec3i 2
        let min = (lastPlayerLocation - halfVisRange) * Vec3i(1, 1, 0)
        let max = min + visRange - Vec3i(1)
        let sbase = chunkLocationToSegmentLocation min
        let ssize = chunkLocationToSegmentLocation (max - min + Vec3i 1)

        let! newSegments = seqBase2D sbase ssize |> Seq.choose (fun p ->
            match segments.TryGetValue(p) with
            | false, _ -> Some (this.CreateSegment p)
            | _        -> None
        )

        newSegments |> Array.iter (fun seg -> segments.Add(seg.Location, seg))
        do! seqBase2D sbase ssize |> Seq.map (fun p -> segments.[p].RebuildSegmentMaybe lastPlayerLocation min max)

        let v = map.Segments()
        segments.Values |> Seq.iter (fun s -> v.Add(s.Segment))

        let mutable msg = C.Messages.MapSwap.New()
        msg.Map <- map
        do! sendMessageAndDispose msg
    }

    member this.Map = map

    member this.RebuildMaybe (player : Vec3i) = coroutine {
        let sw = Stopwatch()
        sw.Start()
        if lastPlayerLocation <> player then
            lastPlayerLocation <- player
            do! this.Rebuild()
        sw.Stop()
        printfn "map update done in: %A" sw.Elapsed
    }
	namespace NG.FS.VoxelMap.Components

	open System
	open System.IO
	open System.Diagnostics
	open System.Collections.Generic
	open NG.FS.VoxelMap.Common
	open NG.FS.Math
	open NG.FS.Coroutines
	open NG.FS.ArrayUtils
	open NG

	type RequestType =
	\| Read
	\| Write

	type Operation =
	\| Grab
	\| Release

	type Request = {
	Type : RequestType
	Location : Vec2i
	Size : Vec2i
	Data : C.MapChunkColumn[,]
	}

	type DeferredRequest = {
	Request : Request
	Coroutine : Coroutine
	}

	[<Struct>]
	type ChunkColumnInfo =
	val mutable Readers : int
	member this.HasWriter = this.Readers = -1
	member this.HasReaders = this.Readers > 0

	// Location is in storage chunks
	type StorageChunk (location : Vec2i) =
	let storageChunk = C.MapStorageChunk.New()
	let fileName = sprintf "%08X_%08X.ngc" location.X location.Y

	member val ColumnsInfo = createArray2D STORAGE_CHUNK_SIZE.XY (ChunkColumnInfo(Readers=0))

	member sc.Save (dir : string) = routine {
	storageChunk.Serialize()
	do! coroutine_p(Type = IO) { storageChunk.SaveData(Path.Combine(dir, fileName)) }
	}

	member sc.Load (dir : string) = routine {
	let! loaded = coroutine_p(Type = IO) { return storageChunk.LoadData(Path.Combine(dir, fileName)) }
	if loaded then
	storageChunk.Deserialize()
	return loaded
	}

	member sc.Generate () = routine {
	let baseLoc = storageChunkLocationToChunkColumnLocation location
	let generateColumn (loc : Vec2i) = coroutine {
	C.MapGenerator.GenerateColumn(storageChunk.Column(loc), baseLoc + loc)
	}
	do! initFlatArray2D STORAGE_CHUNK_SIZE.XY generateColumn
	}

	member sc.Column (p : Vec2i) = storageChunk.Column(p)

	member sc.Dispose () = (sc :> IDisposable).Dispose()
	interface IDisposable with
	member sc.Dispose () = storageChunk.Dispose()

	type Storage (dir : string) =
	let storageChunks = Dictionary<Vec2i, StorageChunk option>()
	let deferredRequests = List<DeferredRequest>()
	let mutex = Mutex()

	let addSelfToDeferredRequests r =
	let c = Scheduler.CurrentCoroutine()
	let dr = { Request = r; Coroutine = c }
	deferredRequests.Add(dr)

	let applyRequest (r : Request) (op : Operation) =
	let mutator =
	match op with
	\| Grab ->
	match r.Type with
	\| Read -> fun (info : ChunkColumnInfo) ->
	ChunkColumnInfo(Readers = info.Readers+1)
	\| Write -> fun (info : ChunkColumnInfo) ->
	ChunkColumnInfo(Readers = -1)
	\| Release ->
	match r.Type with
	\| Read -> fun (info : ChunkColumnInfo) ->
	ChunkColumnInfo(Readers = info.Readers-1)
	\| Write -> fun (info : ChunkColumnInfo) ->
	ChunkColumnInfo(Readers = 0)

	seqBase2D r.Location r.Size \|> Seq.iter (fun p ->
	// storage chunk location for this chunk column
	let scloc = chunkColumnLocationToStorageChunkLocation p
	// chunk column location relative to storage chunk (that is location inside the storage chunk)
	let scp = p - (storageChunkLocationToChunkColumnLocation scloc)
	match storageChunks.[scloc] with
	\| Some sc ->
	sc.ColumnsInfo.[scp.Y, scp.X] <- mutator sc.ColumnsInfo.[scp.Y, scp.X]
	\| None -> failwith "never happens")

	// The last parameter is used to queue loading of a storage chunk (given location).
	// Usually you need to do so when request arrives, but not for deferred requests.
	// Also it breaks cyclic dependency.
	let trySatisfyRequest (r : Request) (queueStorageChunk : Vec2i -> unit) =
	let result = ref true
	seqBase2D r.Location r.Size \|> Seq.iter (fun p ->
	// storage chunk location for this chunk column
	let scloc = chunkColumnLocationToStorageChunkLocation p
	// chunk column location relative to storage chunk (that is location inside the storage chunk)
	let scp = p - (storageChunkLocationToChunkColumnLocation scloc)
	// chunk column location relative to result array
	let rp = p - r.Location
	match storageChunks.TryGetValue(scloc) with
	\| true, Some sc ->
	let info = sc.ColumnsInfo.[scp.Y, scp.X]
	match r.Type with
	\| Read ->
	if info.HasWriter then
	result := false
	\| Write ->
	if info.HasReaders then
	result := false
	r.Data.[rp.Y, rp.X] <- sc.Column scp
	\| true, None ->
	result := false
	\| false, _ ->
	// Here we should also spawn the loading coroutine
	result := false
	storageChunks.[scloc] <- None
	queueStorageChunk scloc
	)

	if !result then
	applyRequest r Grab

	!result

	let trySatisfyDeferredRequest (dr : DeferredRequest) =
	if trySatisfyRequest dr.Request ignore then
	Scheduler.Go dr.Coroutine
	true
	else
	false

	let trySatisfyDeferredRequests () =
	deferredRequests.RemoveAll (Predicate trySatisfyDeferredRequest) \|> ignore

	// 1. Does loading/generation.
	// 2. Locks the mutex.
	// 3. Writes result to storageChunks dict
	// Note: caller should write "None" to storageChunks before executing this coroutine.
	let loadOrGenerateStorageChunk (loc : Vec2i) = coroutine {
	let sc = new StorageChunk(loc)
	let! loaded = sc.Load(dir)
	if not loaded then
	do! sc.Generate()

	do! lockMutex(mutex)
	storageChunks.[loc] <- Some sc
	trySatisfyDeferredRequests()
	}

	let queueStorageChunk (loc : Vec2i) =
	Scheduler.Go (loadOrGenerateStorageChunk loc)

	// Location and size is in chunk columns
	member this.AcquireChunkColumns (r : RequestType) (loc : Vec2i) (size : Vec2i) = coroutine {
	do! lockMutex(mutex)

	let req = { Type = r; Location = loc; Size = size; Data = zeroCreateArray2D size }
	if not (trySatisfyRequest req queueStorageChunk) then
	// If request cannot be satisfied immediately, we will queue ourselves
	// and sleep. Eventually somebody will satisfy it.
	addSelfToDeferredRequests req
	do! sleep()

	return req
	}

	member this.ReleaseChunkColumns (r : Request) = coroutine {
	do! lockMutex(mutex)
	applyRequest r Release
	trySatisfyDeferredRequests()
	}

	type ChunkMeshType =
	\| GraphicsOnly
	\| PhysicsAndGraphics

	[<AllowNullLiteral>]
	type ChunkMesh (t : ChunkMeshType) =
	let mutable refCount = 1
	let chunkMesh = C.MapChunkMesh.New()

	member this.RefCount = refCount
	member this.ChunkMesh = chunkMesh
	member this.VerticesCount = chunkMesh.VerticesCount()
	member val Type = t
	member val VerticesOffset = 0 with get, set

	member this.Dispose () = (this :> IDisposable).Dispose()
	interface IDisposable with
	member this.Dispose () =
	refCount <- refCount - 1
	if refCount = 0 then
	chunkMesh.Dispose()

	member this.Mesh (columns : C.MapChunkColumn[,]) (z : int) =
	use a = C.MapChunkColumnArray.New(4)
	a.SetNth(0, columns.[0, 0])
	a.SetNth(1, columns.[0, 1])
	a.SetNth(2, columns.[1, 0])
	a.SetNth(3, columns.[1, 1])
	chunkMesh.Mesh(a, z)

	member this.Grab () =
	refCount <- refCount + 1
	this

	type Segment (segment : C.MapSegment, location : Vec2i, storage : Storage) =
	let mutable current = zeroCreateArray3D<ChunkMesh> SEGMENT_SIZE
	let mutable next = zeroCreateArray3D<ChunkMesh> SEGMENT_SIZE
	let mutable lastPlayerLocation = Vec3i Int32.MaxValue // in chunks

	let getChunkMeshType (player : Vec3i) (p : Vec3i) =
	let d = Vec3i.ChebyshevDistance player p
	if d <= 2 then PhysicsAndGraphics else GraphicsOnly

	let swap () =
	let tmp = current
	current <- next
	next <- tmp

	next \|> Array3D.iter (fun cm -> if not (isNull cm) then cm.Dispose())
	fillArray3D next null

	let chunkMeshUpload (cm : ChunkMesh) = coroutine {
	let mutable msg = C.Messages.MapChunkMeshAppend.New()
	msg.Segment <- segment
	msg.ChunkMesh <- cm.ChunkMesh
	do! msg

	cm.VerticesOffset <- msg.OutVerticesOffset
	msg.Dispose()
	}

	let chunkMeshBuildAndUpload (ap : Vec3i) (cm : ChunkMesh) = coroutine {
	let! r = storage.AcquireChunkColumns Read (ap.XY - Vec2i 1) (Vec2i 2)
	cm.Mesh r.Data ap.Z
	do! storage.ReleaseChunkColumns r

	if cm.VerticesCount <> 0 then
	let mutable msg = C.Messages.MapChunkMeshAppend.New()
	msg.Segment <- segment
	msg.ChunkMesh <- cm.ChunkMesh
	do! msg

	cm.VerticesOffset <- msg.OutVerticesOffset
	msg.Dispose()
	else
	cm.VerticesOffset <- 0
	}

	member private this.RebuildSegment (min : Vec3i) (max : Vec3i) = routine {
	let baseLoc = segmentLocationToChunkLocation location
	let buildAndUpload =
	seqBase3D (Vec3i 0) SEGMENT_SIZE
	\|> Seq.filter (fun p -> min .<= p && p .<= max)
	\|> Seq.choose (fun p ->
	let ap = baseLoc + p
	let cmtype = getChunkMeshType lastPlayerLocation ap
	let cm = current.[p.Z, p.Y, p.X]
	if not (isNull cm) && cm.Type = cmtype then
	next.[p.Z, p.Y, p.X] <- cm.Grab()
	None
	else
	let cm = new ChunkMesh(cmtype)
	next.[p.Z, p.Y, p.X] <- cm
	Some (chunkMeshBuildAndUpload ap cm)
	)

	let upload =
	seqBase3D (Vec3i 0) SEGMENT_SIZE
	\|> Seq.filter (fun p -> let cm = next.[p.Z, p.Y, p.X] in not (isNull cm) && cm.RefCount = 2)
	\|> Seq.map (fun p -> chunkMeshUpload next.[p.Z, p.Y, p.X])

	do! upload
	do! buildAndUpload

	seqBase3D (Vec3i 0) SEGMENT_SIZE
	\|> Seq.iter (fun p ->
	let cm = next.[p.Z, p.Y, p.X]
	if not (isNull cm) && cm.VerticesCount <> 0 then
	segment.AppendInfo(p, cm.VerticesOffset, cm.VerticesCount)
	)

	let mutable msg = C.Messages.MapSegmentSwap.New()
	msg.Segment <- segment
	do! sendMessageAndDispose msg

	swap()
	}

	member this.Segment = segment
	member this.Location = location

	// all Vec3i parameters are in chunks
	member this.RebuildSegmentMaybe (player : Vec3i) (min : Vec3i) (max : Vec3i) = coroutine {
	if lastPlayerLocation <> player then
	lastPlayerLocation <- player
	do! this.RebuildSegment min max
	}

	member this.Dispose () = (this :> IDisposable).Dispose()
	interface IDisposable with
	member this.Dispose () =
	segment.Dispose()

	type Map (storage : Storage) =
	let map = C.Map.New();
	let segments = Dictionary<Vec2i, Segment>();
	let viewDistance = 400
	let mutex = Mutex()
	let mutable lastPlayerLocation = Vec3i Int32.MaxValue // in chunks

	member private this.CreateSegment (loc : Vec2i) = coroutine {
	let mutable msg = C.Messages.MapSegmentNew.New()
	msg.Location <- loc
	do! msg

	let s = new Segment(msg.OutSegment, loc, storage)
	msg.Dispose()
	return s
	}

	member private this.Rebuild () = routine {
	let viewChunks = viewDistance / CHUNK_SIZE_I
	let visRange = Vec3i(viewChunks * 2, viewChunks * 2, STORAGE_CHUNK_SIZE.Z)
	let halfVisRange = visRange / Vec3i 2
	let min = (lastPlayerLocation - halfVisRange) * Vec3i(1, 1, 0)
	let max = min + visRange - Vec3i(1)
	let sbase = chunkLocationToSegmentLocation min
	let ssize = chunkLocationToSegmentLocation (max - min + Vec3i 1)

	let! newSegments = seqBase2D sbase ssize \|> Seq.choose (fun p ->
	match segments.TryGetValue(p) with
	\| false, _ -> Some (this.CreateSegment p)
	\| _ -> None
	)

	newSegments \|> Array.iter (fun seg -> segments.Add(seg.Location, seg))
	do! seqBase2D sbase ssize \|> Seq.map (fun p -> segments.[p].RebuildSegmentMaybe lastPlayerLocation min max)

	let v = map.Segments()
	segments.Values \|> Seq.iter (fun s -> v.Add(s.Segment))

	let mutable msg = C.Messages.MapSwap.New()
	msg.Map <- map
	do! sendMessageAndDispose msg
	}

	member this.Map = map

	member this.RebuildMaybe (player : Vec3i) = coroutine {
	let sw = Stopwatch()
	sw.Start()
	if lastPlayerLocation <> player then
	lastPlayerLocation <- player
	do! this.Rebuild()
	sw.Stop()
	printfn "map update done in: %A" sw.Elapsed
	}