Struct ChunkGenerationTask 

pub struct ChunkGenerationTask {
    pub chunk_map: Arc<ChunkMap>,
    pub pos: ChunkPos,
    pub target_status: ChunkStatus,
    pub scheduled_status: SyncMutex<Option<ChunkStatus>>,
    pub cancel_token: CancellationToken,
    cancelled: AtomicBool,
    pub neighbor_ready: SyncMutex<Vec<NeighborReady>>,
    pub cache: Arc<StaticCache2D<Arc<ChunkHolder>>>,
    pub center_holder: Arc<ChunkHolder>,
    pub needs_generation: AtomicBool,
    pub thread_pool: Arc<ThreadPool>,
}

A task responsible for driving a chunk to a target status.

It works in form of layers. Imagine a pyramid, to get to the top you first need to generate the base layer. And so on. This works in the same way but with chunk dependencies.

This is achieved using the Generation Pyramid and Loading Pyramid.

To make sure a chunk is only put through a stage once it uses an atomic with a CAS operation. Loading Pyramid must also be advanced with noop functions so this atomic can be driven forward.

Fields

chunk_map: Arc<ChunkMap>

The chunk map associated with this task.

pos: ChunkPos

The chunk position.

target_status: ChunkStatus

The target generation status.

scheduled_status: SyncMutex<Option<ChunkStatus>>

The status scheduled for generation. Protected by a mutex for safe concurrent access.

cancel_token: CancellationToken

Cancellation token — cancelled when this task should stop.

cancelled: AtomicBool

Cheap cancellation flag for scheduler-side filtering.

neighbor_ready: SyncMutex<Vec<NeighborReady>>

Futures for neighbors. Protected by a mutex.

cache: Arc<StaticCache2D<Arc<ChunkHolder>>>

Cache of required chunks.

center_holder: Arc<ChunkHolder>

Holder for the chunk this task is targeting.

needs_generation: AtomicBool

Whether generation is required for this task.

thread_pool: Arc<ThreadPool>

The thread pool to use for generation.

Implementations

impl ChunkGenerationTask

pub fn new( pos: ChunkPos, target_status: ChunkStatus, chunk_map: Arc<ChunkMap>, thread_pool: Arc<ThreadPool>, cancel_token: CancellationToken, ) -> Self

Creates a new generation task.

pub fn cancel(&self)

Cancels this task by triggering the cancellation token.

pub fn is_cancelled(&self) -> bool

Returns whether this task has been explicitly cancelled.

pub(crate) const fn center_holder(&self) -> &Arc<ChunkHolder>

Returns the holder for the chunk this task is targeting.

pub fn schedule_chunk_in_layer( &self, status: ChunkStatus, needs_generation: bool, chunk_holder: &Arc<ChunkHolder>, ) -> bool

Schedules a chunk for a specific layer.

Panics

Panics if generation is required but not expected.

pub fn schedule_layer(&self, status: ChunkStatus, needs_generation: bool)

Schedules tasks for the current layer’s neighbors.

const fn get_radius_for_layer( &self, status: ChunkStatus, needs_generation: bool, ) -> i32

pub fn schedule_next_layer(&self)

Schedules the next layer of generation dependencies.

Panics

Panics if the schedule is invalid.

fn can_load_without_generation(&self) -> bool

pub async fn run(self: Arc<Self>)

Runs the generation task loop.

pub async fn wait_for_scheduled_layers(&self)

Waits for all scheduled neighbor tasks to complete.