Creating a voxel grid from several bitmaps

Thank you for the great reply, way more than i had anticipated :D

The guide you've linked, to create voxels, thats just a chunk though, and from the guide it appears that it is limited to 65000 points, do you have a theory as to how i'd load a map like this into several chunks?

This is a whole new chapter in program$$anonymous$$g for me, and i find it quite complicated :)

Yes, you need to implement chunks, but that is rather trivial really. It's basically like this:

The script that generated the mesh sits on a gameObject (one chunk). You pass it the whole block array as well as the starting and ending xyz values. Then you do the normal mesh generation, but you don't iterate through every block in the block array, but rather only through the blocks inside that specific chunk's xyz values.

The chunk objects themselves are referenced in their own three-dimensional array, with this array's dimensions being deter$$anonymous$$ed by the cell dimensions each chunk should have. So if you have a block array with a xyz length of, say, 9, and your chunk should have xyz lengths of 3, then your chunk array would have a xyz length of 3 (9/3).

So to put things in order:

1. Define chunk array ( GameObject[,,] or ChunkRender[,,])

2. Iterate through chunk array, instantiating a prefab at each position. The prefab would be a gameObject with meshfilter, meshrenderer, meshcollider, and the ChunkRender script.

3. Access the instantiated chunk's ChunkRender script and set the xyz starting and end values

4. When the loops are finished, you can call another function that iterates through the chunk array again and calls the ChunkRender function on their scripts. This is what you would do if you would want to update all the chunks during runtime.

Edit: Oh, and if you want more information... After playing $$anonymous$$ecraft...

Edit2:

 int x = 0;
 int y = 0;
 int z = 0;
 
 int worldSize_x = 9;
 int worldSize_y = 9;
 int worldSize_z = 9;
 
 int chunkSize_x = 3;
 int chunkSize_y = 3;
 int chunkSize_z = 3;
 
 ChunkRenderer[,,] chunkArray = new ChunkRenderer[worldSize_x / chunkSize_x,worldSize_y / chunkSize_y,worldSize_z / chunkSize_z];
 
 //create chunks... note that it doesn't matter where the chunk gameobject is located because it's the mesh's vertices that count
 for (x = 0; x < chunkArray.GetLength(0); x ++) {
      for (y = 0; y < chunkArray.GetLength(1); y++) {
           for (z = 0; z < chunkArray.GetLength(2); z++)    {
            GameObject chunkCur = Instantiate(chunkPrefab, transform.position, Quaternion.identity) as GameObject;
                ChunkRenderer chunkRenderer = chunkCur.GetComponent<ChunkRenderer>();
                
                chunkRenderer.start_x = x * chunkSize_x;
                chunkRenderer.start_y = y * chunkSize_y;
                chunkRenderer.start_z = z * chunkSize_z;
                 
                chunkArray[x,y,z] = chunkRenderer ;
           }
      }
 }
 
 //Update all chunks
 for (x = 0; x < chunkArray.GetLength(0); x ++) {
      for (y = 0; y < chunkArray.GetLength(1); y++) {
           for (z = 0; z < chunkArray.GetLength(2); z++)    {
                chunkArray[x,y,z].ChunkRender(blockArray);
           }
      }
 }

Inside the ChunkRender function, the xyz loop would look like this

 for (x = chunkStart_x; x < chunkStart_x + chunkSize_x; x++)
         {
             for (y = chunkStart_y; y < chunkStart_y + chunkSize_y; y++)
             {
                 for (z = chunkStart_z; z < chunkStart_z + chunkSize_z; z++)

I also edited my original answer, one paragraph waas at the wrong place, this one:

Note that this array has only one dimension. You can populate it with a simple function, or just set it's length in the editor and drag the textures into it in the right order.

Belongs under the code that declares the Texture array.

Wish i could give you more upvotes on this, you're really helping me a lot :)