It failed.

Time Machine complained about write permissions. Nothing was restored. My heart skipped a beat. After Googling around for a few hours and trying all sorts of things, I finally got it to work. The result is documented here just in case you run into the same issue. I hope it saves you time!

Fixing a busted Time Machine

First, go to the very top of your directory tree where all disks are mounted. Make sure your backup drive is attached and alive.

% cd /Volumes

Look for the volume that represents your backup drive. cd to that:

%cd ScottBackup
%cd Backups.backupdb

Now start looking through the mount point, shown here as /Volumes/ScottBackup/Backups.backupdb. You’ll notice that the directory tree begins with the name of your computer, followed by a set of directories, each of them named with a timestamp. Mine look like this:

2011-01-11-003733/            2011-01-29-030503/

These are in the format of YYYY-MM-DD-time. Pick one that you want to restore, and cd to that directory. Here I choose a backup at 3:05am on January 29th:

% cd 2011-01-29-030503

The top level directory should look like your hard drive:

% ls
Macintosh HD/

Surf through these directories. It should mirror your existing drive. Under the covers, however, Mac OS/X seems to be hacking the file system. The files don’t actually exist in multiple copies. Instead, they’re layered into a database and made to appear as though they’re in one piece. No matter.

Find the directory you want to restore. Now comes the tricky part.

First, create a tarball of your disk and place it on ~/Desktop. Let’s assume for this example that my directory is /Users/spenberthy/myapp/lostdir:

% cd Users/spenberthy/myapp
% tar cfvz ~/Desktop/lostdir.tar.gz lostdir

This will take a bit of time for a large directory. You’ll hear your backup disk grind as OS/X reassembles all the files, reads them, and stuffs them into the tarball.

Now get out of there. Move to your desktop:

% cd ~/Desktop

Decide where you want to restore the files, then move there:

% cd ~/myapp

For the first pass, unload the tarball onto your hard drive:

% tar xfvz ~/Desktop/lostdir.tar.gz

You’ll be greeted with numerous permission errors. Ignore them. We’re almost there. If you list the files that you restored using “ls -l”, you’ll notice something odd:

% ls -l
total 22800
-rw-r--r--+   1 spenberthy  staff    56B Aug  5 17:17 README
drwxr-xr-x+  10 spenberthy  staff   340B Jan 29 06:46 Reachability/
drwxr-xr-x+  14 spenberthy  staff   476B Jan 29 06:46 Twitter-OAuth-iPhone/
drwxr-xr-x+   8 spenberthy  staff   272B Jan 29 06:46 certs/

See those plus signs on the left? Well, they were new to me. These are called extended permissions and use an elaborate, English-like syntax. To see these use the command “ls -lE@”:

% ls -le@
total 22800
-rw-r--r--+   1 spenberthy  staff    56B Aug  5 17:17 README
 0: group:everyone deny write,delete,append,writeattr,writeextattr,chown
drwxr-xr-x+  10 spenberthy  staff   340B Jan 29 06:46 Reachability/
 0: group:everyone deny add_file,delete,add_subdirectory,delete_child,writeattr,writeextattr,chown
drwxr-xr-x+  14 spenberthy  staff   476B Jan 29 06:46 Twitter-OAuth-iPhone/
 0: group:everyone deny add_file,delete,add_subdirectory,delete_child,writeattr,writeextattr,chown
drwxr-xr-x+   8 spenberthy  staff   272B Jan 29 06:46 certs/

Those permissions are the problem. Let’s get rid of them.

% chmod -R -a# 0 *

If you list the contents again, your extended permissions should be gone, as well as that mysterious plus sign:

% ls -l
total 22800
-rw-r--r--    1 spenberthy  staff    56B Aug  5 17:17 README
drwxr-xr-x   10 spenberthy  staff   340B Jan 29 06:46 Reachability/
drwxr-xr-x   14 spenberthy  staff   476B Jan 29 06:46 Twitter-OAuth-iPhone/
drwxr-xr-x    8 spenberthy  staff   272B Jan 29 06:46 certs/

You’re done! In case you’re wondering, these files are for a new app I’m building with some friends and relatives at DX Agency. More on that later.

Today I was searching for code to create an interactive, 3D earth with a single UIViewController that reads from Geo RSS. It should work on an iPhone, IPod Touch, and an iPad. I need this for several apps we’re writing in 2011. The interface should be as simple as

EarthViewController *evc = [[EarthViewController alloc] initWithFeed: @"url"]

The controller handles OpenGL, animation, touch interaction, XML parsing, favorites, glowing dots, 3d pan and 3d zoom. The controller is fully interactive. Pinch to zoom out, pull to zoom in. Flick your finger and watch the globe spin. Hit play/pause to watch it rotate in real time, updating live with a Geo RSS feed. Make this configurable for every N seconds. When a dot is selected, return an NSDictionary with the contents of the selected GeoRSS entry.

I’m offering it for $499 to offset my costs. This includes a header file EarthViewController.h, a binary library EarthViewController.a, and a sample app with a stock RSS feed. The OpenGL interface uses OpenGL ES 2.0 with pixel shaders for a professional, high-end look and feel. Contact me if you need a controller like this, too!

A mesh and Lomo filter on the iPhone

I recently “discovered” OpenGL Shading Language on the iPhone, or GLSL for short. Its incredible. The iPhone chipset compiles a C-like language on the fly, producing byte codes for the GPU. These in turn are processed in two phases at interactive frame rates:

1. Vertex Shader – Compute where a pixel is drawn
2. Fragment Shader – Compute what’s drawn for each pixel

Readers will recall my experiments with Milkdrop, flash visualization, and image morphing math. The OpenGL Shading Language takes it to a whole new level, stuffed into a large, orange, 740-page reference guide.

I wondered if I could build a real-time visualizer on the iPhone using GLSL, applying a surface mesh to a live data feed, all at interactive rates. This could be the groundwork for visualizing massive data clouds we’re all building these days.

Sure enough, you can.

I’m working on an app tentatively titled, “FunHouse Mirror.” That’s probably the best way to explain what happens. Yes, there are other copies in the App Store. What makes mine unique is that the filters are infinite and programmable.

Inspired by Milkdrop, I built an engine for morphing video instead of audio. Instead of presets, the app downloads shaders, compiles them, shows me the compiler & linker results in a popup window. If no errors are found, the engine installs the vertex and fragment shaders. Then the magic happens.

The engine senses the compass, accelerometer, orientation, GPS location and time. It computes several waveforms on demand. It grabs the raw bytes from the forward facing camera as a data feed. These are passed into the visualizer, which changes the visual effect like Milkdrop based on ever-changing data. It’s stunning.

The result is live, interactive, morphing video. I also find that it’s a wonderful tool for testing out shader ideas, learning how math shapes surfaces, figuring out the best way to visualize a data set. The engine takes care of all the headache of sampling data, working with OpenGL, compiling shaders, building a mesh, establishing textures, interacting with the user, displaying views, all that rot.

Instead, you can write a simple shader like this.

/*
 * Roaming fisheye effect
 *
 */

vec4 FishEye()
{
        float dt = (f_parms[TIME] - 0.0*floor(f_parms[TIME]))*3.14;
        float cx = 0.4+3.0*(f_parms[ROLL]-0.08);
        float cy = 0.4+6.0*(f_parms[PITCH]+0.85);
        vec2 ray = v_texCoord-vec2(cx,cy);
        float r = length(ray);
        float theta = atan(ray.y,ray.x);
        float rs = (r*r)/0.7;
        vec2 pixel = vec2(cx+rs*cos(theta), cy+rs*sin(theta+dt*0.0));

        return texture2D(campic, pixel);
}

void main()
{
        gl_FragColor = FishEye();
}

The shader is tested and installed with a single tap. I’m also building up a library of functions for representing Photoshop effects and convolutions, in real time, with shaders.

More iPhone Cool Projects

One of the more popular posts on this blog is a little list of iPhone fonts. When I first started writing iPhone apps, I was puzzled by the lack of documentation on font names within the wonderful little devices. My post gets visited daily by dozens of programmers who, apparently, run across the same issue.

My love/hate relationship with fonts began in college. I made pizza and beer money by encoding my friends’ papers into Scribe, an early word processing program. Later in grad school I learned how to hack LaTex, and once contributed a few morsels to the AAAI library for publishing AI papers. After my PhD thesis my advisor introduced me to a mailing list at CERN, run by a guy named Tim. I was smitten BY his vision of a World Wide Web. I looked for months to find Web work at IBM, and finally landed a job building a rendering engine for IBM’s first browser. Most of my coding efforts were spent wrestling OS/2 presentation manager and… you guessed it… fonts. They seemed inescapable.

Fast forward a decade and a half. At the beginning of my iPhone career, I landed a sweet deal working on an iPhone game for DreamWorks. We were cruising along when the creative team decided to use a custom font. Uh oh. I faced having to rewrite a lot of Apple’s font mechanisms with very little investment. I didn’t have time. I needed something practical, something that would let me build a font package quickly.

The project tapped some dusty memories from Scribe, LaTex, OS/2, and now OpenGL. The end result was a quick, useful set of classes and tools for converting any TrueType font into a mipmapped OpenGL font on the iPhone. Word spread, and soon I found myself writing a chapter from APress about the experience.

I hope the chapter saves you, and other programmers, tons of time in writing and building quick, lightweight font engines!

The App Fund

I read today about The App Fund. They’re looking for killer apps that will run on an iPad, targeted at early adopters. Funding starts at $5000 and grows to $500k for a fully funded app with marketing. We would be happy to build the app for you!

Sausage Pad

Having trouble using that iPhone while wearing gloves? No problem! By a Jimmy Dean and slap that baby on the screen instead of your sticky mitts. Its all the rage in South Korea.

The Google Tablet

Google “leaked” their tablet concept for Chrome yesterday. The video depicts an even larger format, a 24″ screen laying flat on your desktop.

Apple is clearly #1 in the App universe. I love writing code for their wonderful devices. The recent, mocking attacks from the Twitterverse and Blogosphere remind me of a famous quote:

Deadly Nadder from Flame It!

Last fall Ben Preuss called me from ThinkNerve. Ben runs a fantastic little studio in Brooklyn, partnering with Hollywood boutiques, producing dozens of Flash widgets and microsites. I’ve always been an admirer of his work.

Ben had an iPhone project called “Flame it!” and wanted to know if we could help. The idea was silly but fun: transform your breath into a fire-breathing dragon. Sounds simple enough. Today we submitted it to the App store. Shortly we’ll submit the native French and German versions.

Yet, when all was said and done, the App had to be written in OpenGL, CoreAudio, C and C++. The menus were all custom, maintaining the look and feel of the movie. Listening to your breath, processing the audio, then controlling the stereo sound and flame in real time required a bit more work than I originally thought. The audio engine is custom, as you’re recording, playing and animating sounds in a real-time loop with less than a 10msec delay.

After I got audio working — suspending correctly, resuming without hanging, and handling sound effects in real time — I had to create a new particle engine for the flames, inspired by the fabulous work of Particle Illusion. It should be able to play all effects from their library of thousands, some of which were used in 2012 and other Hollywood films. So fun. As the movie draws closer, new flames and particle engines will showcase the unique character of the starring Dragons. You can even use a multiplayer mode, flaming particles across a local WiFi network in real time using UDP.