Four-Tri Burger

This is a 3D model I was inspired to make by Stuart Brown’s excellent Four-Byte Burger documentary video on YouTube. The video discusses “Four-Byte Burger”, a pixel art image by Jack Haeger made on an Amiga machine. I’ve used a variety of techniques while making this, as translating a flat pixel art image into a three-dimensional object comes with some challenges, questions, and opportunities for creativity and reinterpretation.

Final Image

The model can be viewed and downloaded at Sketchfab.com.

The process

Considerations

It’s a good idea to begin any project by planning out the main goals and milestones, and gathering all of the relevant and helpful reference material. In this case, the big milestones ended up being “meshes of main components”, “textures of main components projected”, “textures of main components redrawn”. Obviously, “project finished” is also a milestone, and every single substep can be broken down further by a specific “ingredient”. The tiny things like droplets of condiments or crumbs of bread are in their own milestone as well.

An important question, and one I still struggle sometimes with, is “what should I atlas?”. An image atlas is a single image contains multiple textures (or textures of multiple objects), and it’s generally really good for performance as hardware has an easier time handling one image instead of multiple. However, an insufficiently planned atlas can introduce horrible issues for the artist or the team - once an area of the image is dedicated to a texture, it’s a really involved process to move it somewhere else. And if it has to be moved into another texture’s area, the problem just cascades.

Thankfully, I had a really convenient scenario for this project - all of the intended ingredients are already present and known, and while them being circular forces a lot of empty space, that empty space is free for whatever surprises or new ideas may show up.

As for references, it was pretty straightforward for this project - grab the original image, grab Stuart’s recreation, switch between both every now and then to check how I’m doing.

Acquiring the texture

Projected Four-Byte Burger texture

Once I’ve got some meshes ready, it’s time to project the existing artwork onto them and then onto a flat image. This can be a somewhat confusing process, so it’s helpful to think about steps of setting it up.

Most projections to or from images in 3D graphics are done using UV coordinates and UV maps, and the path artwork -> meshes -> flat image involves two different projections. I needed two UV maps for this: one generated from Blender’s helpful “project from view”, and another one unwrapped manually, using common unwrapping techniques and taking care to avoid overlaps and maintain good texel density. After that, it was just a question of baking one image to another with Blender’s Cycles render engine. I needed to set up a new material (as I’m dealing with Blender’s baking process), add Stuart’s remade image, create a new blank image (as I’m, still, dealing with Blender’s baking process), correctly connect up the UV coordinates for each image, and that was it. Simple and intuitive! (It’s neither)

Planning the texture

With that out of the way, I had an image with the projection. Even if it’s a really helpful start, there are many issues I’ll need to address and correct - and the scale of work can be considered comparable to drawing the whole texture atlas from scratch.

First, let’s take a look at the issues and make mental notes of them. The most obvious ones are smearing due to projection, and information not being present in the original image. The pickles suffered the most due to projection. Pretty much every ingredient has something from another ingredient on it - the original image had a lot of visible intersections and overlaps, but having them presented like so really makes you feel them. Especially if you’re realizing that you’re going to be editing all of this.

In addition,there are many smaller issues that showed up from projection, mostly relevant to clean pixel art - individual “pixels” in the artwork ended up taking up multiple real pixels, lines aren’t straight or of consistent width, and dithering patterns are warped, stretched and ruined pretty much everywhere.

There’s one thing I could do to make the work both lighter in scope and easier to manage - draw onto a lower-resolution image. The baked projected image benefits from high resolution by being able to capture a discrete pixel into a single smear (instead of blurring neighbors together), but if I’m to draw pixel art on a high-resolution canvas like that, it’s going to take a lot of time and a lot of effort. My final atlas will be a 512 by 512 image.

Drawing the texture

Redrawn Four-Byte Burger atlas texture

Ultimately, the redrawing was about putting on some pleasant music and going through the motions required to finish. It’s especially good to have references handy here, and to think about the construction of the object being drawn. Pickles have a translucent, mushy middle with pale, opaque (and thus capable of casting shadows) seeds suspended inside. Tomato slices have a radially symmetrical like dense (matte, with a treebark-like textured surface) structure on the outside with soft, moist and shiny (deeper, darker, translucent, reflects light) tomato gel held between the “branches”. Lettuce has a network of thin stems permeating the leaf (which are raised, and deserve a highlight from one side, and a shadow from another), and the buns have some charred crumbs from toasting. Finally, I used the empty space to draw a simple texture for the sesame seeds and the breadcrumbs (buncrumbs?) flying about. I also added a tiny pallete in the upper left - I’ll be unwrapping the ketchup, mayonnaise and mustard onto those pixels.

Pixel by pixel, imagining the subject and piecing together its internal mechanics, I’ve been able to eventually redraw the whole projected image. This is where the bulk of the project’s time and effort went into, and only finishing touches remain. The condiments flying everywhere are formed with metaballs, and then converted to mesh for Sketchfab exporting (though I still have them as metaballs in my working file). Crumbs are a very simple mesh extruded out of a plane several times, duplicated and rotated around the scene.