Taichi Voxel Challenge 2022

Voxel Pac-man

I came across Taichi’s voxel-challenge repository quite a while ago. Since I’ve always been a huge fan of pixel art, I naturally kept an eye on voxel art as well; for instance, I previously conducted a deep learning for pixel art¹ survey on the topic. While casually browsing the repository, I stumbled upon an issue #1, which got me super excited to try it out myself. The code is available here, and it roughly looks like this:

Of course, I later found out this was actually an internal beta (x), which explained why I couldn’t find any push notifications about this challenge on the official WeChat account for ages.

Once the official competition started, I tweaked the content, fine-tuned a few parameters to improve it, added some feed balls, and submitted this Voxel Pac-man. It now has a slightly more sophisticated look (x:

The code is about 96 lines long, and the overall logic is quite simple. First, let’s look at what pac-man consists of: there’s the entire spherical body, but with the mouth open, making it incomplete. The upper and lower parts of the mouth should be considered separate surfaces. Then there are the eyes, and finally, the feed balls.

I added a lot of customizable parameters at the beginning of the code for easy adjustment. n defines the size of the entire space. Since I hadn’t looked at the code myself at the time, I didn’t know the space limit was (-64,64), so I just made up a number. The rest involved setting the radius, center point, facing direction, and so on.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@ti.kernel
def initialize_voxels():
    n = 60
    r = 20
    p_center = vec3(0, n // 2, -n // 2)

    vec_face_to = vec3(0, 0, 1)
    vec_z = vec3(0, 1, 0)
    vec_normal = normalize(cross(vec_face_to, vec_z))

    mouse_angle = pi / 5
    mouse_angle_min = mouse_angle
    mouse_angle_max = mouse_angle
    mouse_angle_cos_min = ti.cos(mouse_angle_min) - 0.05
    mouse_angle_cos_max = ti.cos(mouse_angle_max) + 0.05
    skin_thickness = 0.5

    eye_angle = mouse_angle + pi / 18
    he_angle = pi / 5

    vec_eye_left = rotate(rotate(vec_face_to, vec_normal, -eye_angle), vec_z, he_angle).normalized()
    vec_eye_right = rotate(rotate(vec_face_to, vec_normal, -eye_angle), vec_z,
                           -he_angle).normalized()

    p_eye_left = p_center + vec_eye_left * r
    p_eye_right = p_center + vec_eye_right * r
    eye_size = 4

The core logic is as follows: first, draw the skin surface by iterating through x, y, and z. If a point is inside the skin, we need to check if it falls within the mouth area. If it does, we skip drawing it; otherwise, we fill it with the skin color. How do we determine if a point is in the mouth? Looking from the side, if the projection of the point onto the central plane forms an angle with the direction of pac-man that falls within our mouth-opening angle range, then it’s part of the mouth. Finally, we draw the inside of the mouth. The logic is similar: first, ensure the point is inside the skin, then check if it’s within the mouth’s central area. If not, we draw it within a certain range above and below the open mouth. Since voxels might not be perfectly standard, we add some parameters to make it look more pleasing.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

    for i, j, k in ti.ndrange((-n, n), (-n, n), (-n, n)):
        x = ivec3(i, j, k)
        color = vec3(2, 2, 2)
        # surface
        if distance(x, p_center) < r + skin_thickness and distance(x,
                                                                   p_center) > r - skin_thickness:
            # mouse
            # project to the plane
            vec_mouse = vec3(i, j, k) - p_center
            vec_mouse_projected = vec_mouse - vec_normal * dot(vec_mouse, vec_normal)
            print(vec_mouse_projected)
            # angle to face to
            angle_cos = dot(vec_mouse_projected,
                            vec_face_to) / (vec_mouse_projected.norm() * vec_face_to.norm())
            if angle_cos <= mouse_angle_cos_max:
                color = vec3(1, 1, 0.)
            if distance(vec3(i, j, k), p_eye_left) <= eye_size or distance(
                    vec3(i, j, k), p_eye_right) <= eye_size:
                color = vec3(0.01, 0.01, 0.01)

        elif distance(x, p_center) <= r - skin_thickness:
            # mouse
            # project to the plane
            vec_mouse = vec3(i, j, k) - p_center
            vec_mouse_projected = vec_mouse - vec_normal * dot(vec_mouse, vec_normal)
            angle_cos = dot(vec_mouse_projected,
                            vec_face_to) / (vec_mouse_projected.norm() * vec_face_to.norm())

            if mouse_angle_cos_min <= angle_cos and angle_cos <= mouse_angle_cos_max or vec_mouse_projected.norm(
            ) < 3:
                color = vec3(0.0, 0.0, 0.0)
        if any(color != vec3(2, 2, 2)):
            scene.set_voxel(vec3(i, j, k), 2, color)

Drawing the feed balls is relatively straightforward.

1
2
3
4
5
6

@ti.func
def create_feed_ball(feed_r, feed_p, feed_color):
    for i, j, k in ti.ndrange((-feed_r, feed_r), (-feed_r, feed_r), (-feed_r, feed_r)):
        x = ivec3(i, j, k)
        if distance(x, vec3(0, 0, 0)) + 0.5 <= feed_r:
            scene.set_voxel(feed_p + vec3(i, j, k), 2, feed_color)

However, after completing Voxel Fortress, I felt that the whole thing wasn’t that complex; it could probably be done in around 50 lines of code.

Let’s break down the entire pac-man: the surface is a sphere, the mouth is another internal sphere, the eyes are spheres, and the feed balls are also spheres. So, the main elements are all covered. How do we make the mouth open? Simply set the voxel of mat to 0, which effectively deletes it. Then, just insert a horizontal semi-cylinder into the mouth area, and it’s done!!

Voxel Fortress

Are there any voxel-based structures in reality? Besides LEGO, there are bricks! So, let’s build a fortress! (Maybe I’ll make a GW one later too!)

Building this fortress is incredibly simple: just take a cube, add a top cap, and add raised brick blocks on all four sides. One function does it all!

1
2
3
4
5
6
7
8
9

@ti.func
def build_fortress(pos, sz1, sz2, height, color, color_noise):
    for x, y in ti.ndrange((-sz1, sz1 + 1), (-sz2, sz2 + 1)):
        if x == -sz1 or x == sz1 or y == -sz2 or y == sz2:
            for z in range(height):
                set_color_voxel(pos + vec3(x, z, y), 1, color, color_noise, 0.8)
            if (x + y) % 4 == 0 or (x + y) % 4 == 1:
                set_color_voxel(pos + vec3(x, height, y), 1, color, color_noise)
        set_color_voxel(pos + vec3(x, height - 2, y), 1, color, color_noise, 0.8)

Then, we build one large central tower and four corner towers, and that’s it!

Next, we construct the surrounding walls to enclose the fortress. A wall is essentially just a block; we can create a rectangle by specifying the bottom-left and top-right vertices and filling the middle. Of course, the walls should be slightly lower than the corner towers.

1
2
3
4
5
6

@ti.func
def build_block(pos1, pos2, color, color_noise, prob=1, mat=1):
    x_min, y_min, z_min = min(pos1.x, pos2.x), min(pos1.y, pos2.y), min(pos1.z, pos2.z)
    x_max, y_max, z_max = max(pos1.x, pos2.x), max(pos1.y, pos2.y), max(pos1.z, pos2.z)
    for x, y, z in ti.ndrange((x_min, x_max + 1), (y_min, y_max + 1), (z_min, z_max + 1)):
        set_color_voxel(vec3(x, y, z), mat, color, color_noise, prob)

These walls look a bit fragile… like they’d crumble at the slightest touch. Let’s make them thicker and leave space in the middle for soldiers to stand guard. But we also need to protect the soldiers from being hit, so we build them just like the fortress! Originally, the fortress faces were square; by changing them to rectangles and adding length and width parameters, we can create thick, sturdy walls!

Now it really starts to feel like the real thing~

Let’s build a gate; otherwise, how would anyone get in? The gate consists of just a sector and a rectangle, so easy~ The door frame is simply a larger version of the gate.

1
2
3
4

    for i in ti.ndrange((d_ - 2, d_ + 3)):
        build_door(vec3(0, 6, i), 6, 4, vec3(0.6, 0.6, 0.6), vec3(0))
        build_door(vec3(0, 5, i), 5, 3, vec3(0, 0, 0), vec3(0), 1, 0)
    build_door(vec3(0, 5, d_), 5, 3, vec3(0.43, 0.352, 0.156), vec3(0))

Looks pretty good. Let’s add some ground: a layer of dirt topped with grass, and a path leading up to the gate. Also, let’s add windows to the towers on both sides. This is basically just deleting a door.

Injecting some soul!! Adding little torches!!

1
2
3
4

@ti.func
def build_fire(pos):
    scene.set_voxel(pos, 2, vec3(1, 1, 0))
    scene.set_voxel(pos + vec3(0, -1, 0), 1, vec3(0.43, 0.352, 0.156))

Finally, add a tiny doorknob, and we’re done!

And last but not least, I optimized the lighting and exposure, and added a night mode.

Some other thoughts

Because I truly haven’t used Taichi in a long time. I previously watched the graphics course on Taichi on Bilibili, but unfortunately, I was busy with group meetings and various final-term courses back then, so I didn’t complete the major project at that time. I still feel a bit regretful about it. Fortunately, this time I have a chance to work on something I like and also get some hands-on practice! My code does have some areas that could be written better (mainly because I feel not yet fully proficient; many parts slightly conflict with common Python methods, so coding requires some mental shifts.