Fundamental unit of spatial partitioning for procedural world generation. More...

#include <Chunk.hpp>

Collaboration diagram for Infinity::Types::Procedural::Chunk:

Public Member Functions
Math::Vector3	position ()
	Gets the center position of the chunk.

Public Attributes
uint64_t	id
	Unique identifier for this chunk.

Spatial::Volume	vol
	Spatial volume defining the chunk's bounds.

Detailed Description

Fundamental unit of spatial partitioning for procedural world generation.

Chunk represents a discrete spatial region in a procedurally generated world, combining a unique identifier with a spatial volume. This is the core structure for chunk-based world generation systems, enabling:

Spatial partitioning of infinite or large worlds
Streaming and dynamic loading/unloading of content
Level-of-detail (LOD) management across regions
Parallel generation of independent spatial regions
Efficient spatial queries and neighbor lookups
Deterministic regeneration from chunk ID and seed

The chunk system allows procedural content to be generated on-demand as players or cameras move through the world, while maintaining consistency through the unique chunk ID. Each chunk can be independently generated, saved, and loaded, making it ideal for open-world and streaming scenarios.

Common use cases:

Minecraft-style voxel world chunking
Terrain tile generation for large landscapes
Spatial sectors for procedural city generation
Dynamic streaming regions in open-world games
Grid-based level generation
Parallel procedural content generation

Note: The chunk ID should be unique within the world and deterministic based on position.; Common ID schemes: grid coordinates hashed to uint64, Morton codes, or spatial hashing.; The volume defines the chunk's spatial extent for generation and culling.

Example usage:

// Create a chunk from grid coordinates
int chunkX = 5, chunkZ = -3;
uint64_t chunkID = hashChunkCoordinates(chunkX, chunkZ);
 
Chunk chunk;
chunk.id = chunkID;
chunk.vol = Volume(
    16.0f, 256.0f, 16.0f,  // 16x256x16 chunk size
    Vector3{chunkX * 16.0f, 128.0f, chunkZ * 16.0f}
);
 
// Generate chunks around player position
Vector3 playerPos = getPlayerPosition();
int viewDistance = 8;  // chunks
Array<Chunk> chunksToGenerate;
 
for (int x = -viewDistance; x <= viewDistance; ++x) {
    for (int z = -viewDistance; z <= viewDistance; ++z) {
        int cx = static_cast<int>(playerPos.x / 16.0f) + x;
        int cz = static_cast<int>(playerPos.z / 16.0f) + z;
        
        Chunk chunk;
        chunk.id = hashChunkCoordinates(cx, cz);
        chunk.vol = Volume(
            16.0f, 256.0f, 16.0f,
            Vector3{cx * 16.0f, 128.0f, cz * 16.0f}
        );
        chunksToGenerate.push_back(chunk);
    }
}
 
// Use with ProceduralSystem for generation
system->setIn("chunks_to_generate", std::move(chunksToGenerate));
 
// Deterministic chunk generation from ID
void generateChunk(const Chunk& chunk, uint32_t worldSeed) {
    uint32_t chunkSeed = combineSeeds(worldSeed, chunk.id);
    // Generate content deterministically using chunkSeed...
}

Member Function Documentation

◆ position()

Math::Vector3 Infinity::Types::Procedural::Chunk::position ( )

Gets the center position of the chunk.

Convenience method that returns the chunk's volume center position. Equivalent to accessing vol.position directly.

Returns: Center position of the chunk in world space.

Chunk chunk = getChunk(5, 3);
Vector3 center = chunk.position();
// Use for distance calculations, spatial queries, etc.

Member Data Documentation

◆ id

uint64_t Infinity::Types::Procedural::Chunk::id

Unique identifier for this chunk.

A 64-bit unique ID that identifies this chunk within the world. Typically derived from grid coordinates or spatial position to ensure deterministic regeneration and efficient lookups.

Common ID generation schemes:

Hash of (x, z) grid coordinates
Morton code (Z-order curve) encoding
Direct encoding: (x << 32) | (z & 0xFFFFFFFF)
Spatial hash function

Note: The ID should be stable and deterministic for a given spatial region.; Used for chunk caching, saving/loading, and seed combination.

◆ vol

Spatial::Volume Infinity::Types::Procedural::Chunk::vol

Spatial volume defining the chunk's bounds.

Axis-aligned bounding volume that defines the chunk's spatial extent in world space. Used for:

Determining chunk boundaries for generation
Culling and visibility testing
Spatial queries and neighbor detection
Content placement bounds