summaryrefslogtreecommitdiffstats
path: root/src/ChunkStay.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/ChunkStay.h')
-rw-r--r--src/ChunkStay.h97
1 files changed, 97 insertions, 0 deletions
diff --git a/src/ChunkStay.h b/src/ChunkStay.h
new file mode 100644
index 000000000..80b084aee
--- /dev/null
+++ b/src/ChunkStay.h
@@ -0,0 +1,97 @@
+
+// ChunkStay.h
+
+/* Declares the cChunkStay class representing a base for classes that want to wait for certain chunks to load,
+then do some action on them. While the object is enabled, the chunks contained within are locked and will
+not unload
+*/
+
+
+
+
+
+#pragma once
+
+
+
+
+
+// fwd
+class cChunkMap;
+
+
+
+
+
+/** Makes chunks stay loaded until this object is cleared or destroyed
+Works by setting internal flags in the cChunk that it should not be unloaded.
+To optimize for speed, cChunkStay has an Enabled flag, it will "stay" the chunks only when enabled
+and it will refuse chunk-list manipulations when enabled.
+The object itself is not made thread-safe, it's supposed to be used from a single thread only.
+This class is abstract, the descendants are expected to provide the OnChunkAvailable() and
+the OnAllChunksAvailable() callback implementations. Note that those are called from the contexts of
+different threads' - the caller, the Loader or the Generator thread.
+*/
+class cChunkStay
+{
+public:
+ cChunkStay(void);
+ ~cChunkStay();
+
+ void Clear(void);
+
+ /** Adds a chunk to be locked from unloading.
+ To be used only while the ChunkStay object is not enabled. */
+ void Add(int a_ChunkX, int a_ChunkZ);
+
+ /** Releases the chunk so that it's no longer locked from unloading.
+ To be used only while the ChunkStay object is not enabled. */
+ void Remove(int a_ChunkX, int a_ChunkZ);
+
+ /** Enables the ChunkStay on the specified chunkmap, causing it to load and generate chunks.
+ All the contained chunks are queued for loading / generating. */
+ void Enable (cChunkMap & a_ChunkMap);
+
+ /** Disables the ChunkStay, the chunks are released and the ChunkStay
+ object can be edited with Add() and Remove() again*/
+ virtual void Disable(void);
+
+ /** Returns all the chunks that should be kept */
+ const cChunkCoordsVector & GetChunks(void) const { return m_Chunks; }
+
+ /** Called when a specific chunk become available. */
+ virtual void OnChunkAvailable(int a_ChunkX, int a_ChunkZ) = 0;
+
+ /** Caled once all of the contained chunks are available.
+ If returns true, the ChunkStay is automatically disabled by the ChunkMap; if it returns false, the ChunkStay is kept. */
+ virtual bool OnAllChunksAvailable(void) = 0;
+
+ /** Called by the ChunkMap when the ChunkStay is disabled. The object may choose to delete itself. */
+ virtual void OnDisabled(void) = 0;
+
+protected:
+
+ friend class cChunkMap;
+
+
+ /** The chunkmap where the object is enabled.
+ Valid only after call to Enable() and before Disable(). */
+ cChunkMap * m_ChunkMap;
+
+ /** The list of chunks to lock from unloading. */
+ cChunkCoordsVector m_Chunks;
+
+ /** The chunks that still need loading */
+ cChunkCoordsVector m_OutstandingChunks;
+
+
+ /** Called by cChunkMap when a chunk is available, checks m_NumLoaded and triggers the appropriate callbacks.
+ May be called for chunks outside this ChunkStay.
+ Returns true if the ChunkStay is to be automatically disabled by the ChunkMap; returns false to keep the ChunkStay. */
+ bool ChunkAvailable(int a_ChunkX, int a_ChunkZ);
+} ;
+
+
+
+
+