Post History

Chunk loading around player in a 3 dimensional cartesian coordinate space

So I am in the process of creating a voxel sandbox survival game (minecraft clone) in javaFX. I am at a point where I need to come up with a way to load the chunks in my surrounding given a render distance setting.

At first I thought this was a simple as iterating through the chunk coordinates in the players vicinity and adding them to the world if they did not already exist (done by initializing new chunk) or adding a pre-existing chunk if they did (done by `manager`)  such as this: 
```
public ArrayList<Chunk> getChunksToRender() {
//Defines the starting chunk to begin iteration. This chunk is in the corner of the area that should be rendered
//playerChunk is the chunk that the player is currently in.
//Chunks are at locations divisible by 16, e.x 0,0,0 |16,16,0 | 16,32,0
        Point3D start = new Point3D(playerChunk.getLocation().getX() + (renderDistance * bounds),
                playerChunk.getLocation().getY() + (renderDistance * bounds), playerChunk.getLocation().getZ());

        

        chunks = new ArrayList<>();
        for (int i = (int) start.getX(); i < start.getX() + (renderDistance * bounds); i+= bounds) {
            for (int j = (int) start.getY(); j < start.getY() + (renderDistance * bounds); j+= bounds) {
                if (manager.containsChunkWithLocation(new Point3D(i, j, 0))) {
                    chunks.add(manager.getChunkWithLocation(new Point3D(i, j, 0)));
                }
                else {
                    chunks.add(new Chunk().initialize(i, j, 0));
                }
            }
        }
}
```
Where `bounds` is the chunk width and height (Same number, 16x16 in this case). A visual example of what I was going for below. The green arrow represents the order in which the chunks would load, iterating through each one in the players vicinity and loading it:
![Chunk loading concept](https://software.codidact.com/uploads/CBdTVyCQpeoRApWS9FveyzAp)



But I quickly remembered that this 3D space is cartesian and this method quickly falls apart when an axis is encountered. 

How would I go about implementing something that accounts for axis?