How a 3D model becomes voxels

Step 01 · Prepare the triangles

Put every triangle in its final position

A 3D model is built from lots of tiny flat triangles. Before we can place cubes around the duck, every triangle must be moved, rotated, and scaled into the position we see on screen.

Imagine a paper model. Each triangle is a little paper piece. Some pieces belong to a head, beak, or body group that has been moved. We first glue every piece into its final place so we have one complete duck to measure.

Step 02 · Find possible cells

Look near the triangle, not everywhere

The large cube may contain millions of cells. For each triangle, we first find the smallest rectangular group of cells it could possibly touch. Everything outside that group can be skipped immediately.

Search one shelf, not the whole library. If a triangle is near the duck’s beak, there is no reason to inspect boxes near its tail. We draw a snug box around the triangle and only search the tiny boxes inside it.

Technical details

The triangle AABB is converted from world coordinates into a clamped, conservative integer voxel range. Cell size is h = L / N.

for triangle in mesh:
  range = cellsOverlapping(triangle.aabb)
  for cell in range:
    test(triangle, cell)

Work follows overlapping candidates instead of triangleCount × N³.

Step 03 · Find surface voxels

Keep the boxes that really touch the model

A candidate box is only a possibility. We accurately test the triangle against that box. If they touch, the box becomes a surface voxel; if there is a gap, we discard it.

Try sliding a card between them. Imagine the triangle and box are two toys. If there is any direction where a flat card fits completely between them, they are separate. If no card fits, they touch.

Technical details

The triangle–box test uses the Separating Axis Theorem (SAT). It tests the box axes, the triangle normal, and edge-cross-axis directions. Finding one separating axis proves there is no intersection.

if triangleIntersectsBox(triangle, cell):
  surface[cell] = true

The cell center is also used to retain the closest touching triangle, giving the later color step a deterministic source.

Step 04 · Fill the inside

Pour imaginary water around the model

Surface voxels form a shell. To find the inside, we start with empty cells along the outer boundary and let imaginary water spread through neighboring empty cells. Dry cells trapped behind the shell are inside.

Think of a waterproof bath toy. Water moves left, right, up, down, forward, and backward, but cannot pass through the toy’s surface. Any empty box the water cannot reach must be sealed inside the duck, so Solid mode fills it.

Technical details

A six-connected flood fill begins at empty boundary cells. Unvisited empty cells are classified as interior, then receive colors propagated from the closest surface through the same six-neighbor graph.

queue = emptyBoundaryCells()
while queue:
  cell = queue.pop()
  visit empty ±X, ±Y, ±Z neighbors

interior = empty AND not visited

This assumes a watertight surface. A hole lets the flood enter the model, producing zero or fewer interior voxels rather than guessing a repair.

Step 05 · Copy texture colors

Find the matching spot on the model’s sticker

Each surface voxel chooses the triangle closest to its center. A point on that triangle tells us where to look on the model’s flat texture image, and that sampled texture color becomes the voxel’s color.

Imagine the duck is covered by a printed sticker. Drop a dot from the voxel onto the nearest triangle. Describe that dot as a mix of the triangle’s three corners, then use the same mix on the sticker map. That is the color the cube should copy.

Technical details

Barycentric weights locate the closest point inside the triangle and interpolate its three UV coordinates.

uv = w₀uv₀ + w₁uv₁ + w₂uv₂
w₀ + w₁ + w₂ = 1

point = closestPoint(triangle, cell.center)
weights = barycentric(point, triangle)
uv = interpolate(triangle.uvs, weights)
rgb = sRGBToLinear(bilinear(texture, uv))
color = rgb × material.baseColor

Texture transforms and wrapping are applied before bilinear filtering. Materials without readable pixels fall back to their base color.

Step 06 · Draw the voxels

Reuse one cube blueprint thousands of times

Creating a separate 3D mesh for every voxel would be wasteful. Instead, the GPU receives one cube shape plus a short position and color record for each visible voxel, then draws them all together.

One cookie cutter, many cookies. We do not manufacture a new cutter for every cube. We send the same cube blueprint through the GPU repeatedly, changing only where it goes and what color it should be.

Technical details

Each instance contributes three unsigned coordinate bytes and three normalized RGB bytes. A vertex shader combines them with the shared cube vertices, cube minimum, and cell size to reconstruct world position.

instance bytes = 3 coordinate + 3 color
draw calls = 1

position = cubeMin + (voxel + ½) × cellSize + cubeCorner × cellSize

A shader is a small program executed in parallel by the GPU. Here the vertex shader answers: “Where should this corner of this cube go?”

How a 3D model becomes voxels

Try the voxelizer

Follow the six steps

Put every triangle in its final position

Look near the triangle, not everywhere

Keep the boxes that really touch the model

Pour imaginary water around the model

Find the matching spot on the model’s sticker

Reuse one cube blueprint thousands of times