Matt Rajca

Quickly Changing Your Mac's Startup Volume with Alfred

Thu, 10 May 2012 20:05:48 -0500

As I work on projects in Snow Leopard, Lion and Windows, I constantly find myself switching my Mac’s startup volume and rebooting. Utilities such as QuickBoot can streamline this process, though they’re not very accessible and often take up precious space in the menu bar. Why not leverage a keyboard-friendly launcher like Alfred instead?

Creating an Alfred extension that will change your Mac’s startup volume and reboot the machine is trivial:

First, open Alfred’s Preferences and switch to the Extensions tab. Under “Add an Extension to Alfred”, select AppleScript. Enter a name for your extension (for example: “Reboot into Lion”), and press “Create”. Next, give your extension a title (which will appear in Alfred’s search results), as well as a keyword like “reboot”.

In the “AppleScript” text view, paste in the following script:

on alfred_script(q)
    do shell script "bless -mount /Volumes/VOLUME_NAME/ -setBoot -nextonly" with administrator privileges
    tell application "Finder" to restart
end alfred_script

Be sure to replace VOLUME_NAME with the name of the volume you wish to reboot into (as shown in the Finder). If the volume is a Boot Camp partition, include the -legacy flag as an argument to the bless command. Finally, hit “Save” to save your new extension. Ideally, create one such extension for each volume you want to have quick access to.

Toggling Alfred and typing “reboot” will now show our extension(s) among the search results. Invoking the extension(s) will prompt you for your password and reboot your Mac into the desired volume.

Subtle Patterns Safari Extension

Mon, 02 Apr 2012 11:32:24 -0500

I just released a Safari Extension that lets web designers preview any of the first 200 Subtle Patterns as they would appear tiled across their websites’ background. Visit the GitHub project page to download it today!

Batch Applying Rounded Corners to Images with Automator

Sun, 12 Feb 2012 22:17:09 -0600

For the past few years, I have used Picturesque whenever I needed to apply rounded corners to batches of images for one of my web design clients. Picturesque did the job, but its lack of Automator support started getting to me. I had to resort to the ‘Watch Me Do’ action just to apply a preset to an image in a larger image processing workflow.

So recently, I took a day to write a ‘Round Images’ Automator action. Given a set corner radius, border width, and border color, the action rounds any or all of the four corners of the images passed into it, as shown below.

The ‘Round Images’ action is freely available on GitHub, so check it out if you think it will be useful in your workflow.

Auto-Ejecting Disc Image Files Dragged to the Trash

Mon, 05 Sep 2011 13:48:46 -0500

Even with the growth of the Mac App Store, I still find myself constantly downloading, mounting, and eventually trashing DMGs. Almost just as frequently, I am greeted with the following dialog whenever I try to empty the Trash with mounted disc image files inside it:

Fortunately for us, we can overcome this annoyance by creating a Folder Action in Automator. Folder Actions run whenever the contents of a specified directory change – in this case, the current user’s Trash. Any mounted disc image files found inside the Trash will get ejected automatically by our Folder Action.

Open Automator, which can be found inside the Applications directory.
Create a new document and select ‘Folder Action’ from the template chooser.
Click on the ‘Choose folder’ pop-up button and select ‘Other…” from the menu that appears.
When the ‘open’ panel comes up, hit Shift+⌘+G and enter ~/.Trash in the location field; click ‘Go’, followed by ‘Choose’.
Drag a new instance of the ‘Run Shell Script’ action (listed under the Utilities group) from the Library into your workflow.
Set the action’s shell to /usr/bin/python and its input type to ‘as arguments’.
Finally, replace the contents of the placeholder script with the one listed below.

import string, os, sys

lines = os.popen("hdiutil info").readlines()
should_eject = False

for line in lines:
    if line.startswith("image-alias"):
        path = line.split(":")[1]
        image_path = path.lstrip().rstrip()

        if image_path in sys.argv:
            should_eject = True

    elif line.startswith("/dev/") and should_eject is True:
        os.popen("hdiutil eject %s" % line.split()[0])
        should_eject = False

    elif line.startswith("###"):
        should_eject = False

After your new Folder Action is saved, any mounted disc image files dragged to the Trash will get ejected automatically.

Kinect Support for Extreme Tux Racer

Thu, 01 Sep 2011 18:26:56 -0500

Recently, I took a short break from my long-term projects to play around with the official Kinect for Windows SDK. As a mini side-project, I added Kinect support to a classic open source game, Extreme Tux Racer. As Tux accelerates down the racetrack, the user can tilt his or her head left or right to steer the penguin, lean forward to paddle, and lean backward to brake. Tux Racer’s lenient collision detection logic also tends to work in the user’s favor during gameplay. If you’re interested in the project, take a look at the source on github, or check out this quick and rough video of it in action! Kinect support is only available on Windows at the moment.

LLVM, Code Coverage, and Xcode 4

Sun, 14 Aug 2011 20:30:41 -0500

The ability to generate code coverage reports has been one of the notable features missing from the LLVM/Clang compiler. As of June 8, 2011, the Clang frontend can finally generate code coverage reports using the same flags that were supported by GCC. At the time of this writing, these flags haven’t made their way into Xcode’s build settings UI. I have no doubt they will be integrated into a future release of Xcode, but until that happens, we can always compile our own build of Clang and manually pass in the compiler flags necessary to generate code coverage reports.

Below are the steps required to check out, compile, and install the tip-of-tree build of LLVM/Clang.

# check out the source to LLVM
svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm

# check out the source to Clang
cd llvm/tools
svn co http://llvm.org/svn/llvm-project/cfe/trunk clang

# configure the project for compilation
cd..
./configure --prefix=/opt --enable-optimized
make -j8           # build with 8 threads
sudo make install  # install to /opt

If all goes well, a new binary of the Clang compiler should now reside in /opt/bin/. Next, we need to tell Xcode to use our newly-built compiler instead of the build it ships with. This should be done for each target you want to generate code coverage reports, or at the project level. In Xcode, open the Build Settings pane of the desired target and choose ‘Add Build Setting’ from the bottom toolbar; select ‘Add User-Defined Setting’ from the pop-up menu that appears. Enter CC for the setting name and /opt/bin/clang as its value. Xcode will now build the target using our custom-built compiler.

While we’re in the Build Settings pane, find the Other C Flags setting and add -fprofile-arcs and -ftest-coverage on to the list. These flags will tell Clang to generate gcov files for each class in our target.

Lastly, we have to link against libprofile_rt.a (instead of libgcov.a, which was required by GCC). In Xcode 4, switch to your target’s Build Phases pane and expand the ‘Link Binary With Libraries’ section. Click on the ‘Plus’ button, choose ‘Add Other’, and navigate to /opt/lib. Select libprofile_rt.dylib from the list of files.

And that’s it! If you build and run your target, Xcode will now output gcda and gcov files to a well-hidden path inside the DerivedData directory. To find it, right click on your target in Xcode’s Products group, and select ‘Show in Finder’. Navigate up the path hierarchy to the Build folder, as shown below.

Finally, open up the Intermediates/$TARGET.build/$CONFIG/$TARGET.build/Objects-normal/$ARCH subfolder. Inside, you’ll find the aforementioned gcda and gcov files. Since Clang outputs these files in the same format as GCC, they are compatible with tools such as CoverStory.

Adding Code Completion Support to TextMate Bundles

Sat, 09 Jul 2011 21:29:16 -0500

Code completion isn’t a prominent feature in TextMate, but it exists. If you enter some text and hit ‘Escape’ repeatedly, TextMate will cycle through any available code completions. Unfortunately, this only works with the Objective-C and PHP bundles, and all functions and methods suggested exclude parameter lists. Compared to the code completion system in Xcode 4, this isn’t very impressive.

After searching around, I discovered that the PHP bundle does something clever: if you hit ‘Option+Escape’ or select the ‘Completions for Word…’ menu item from the bundle’s action pop-up, TextMate will present a menu of available code completions.

What’s more is, once a completion is accepted, the name of the function along with any parameters will be inserted. You can even tab through each parameter, just like in Xcode! After digging around in TextMate’s Bundle Editor, I was surprised to find that the code to make all of this happen is only 5 lines long:

#!/usr/bin/env ruby -wKU
require ENV['TM_SUPPORT_PATH'] + '/lib/osx/plist'
require ENV['TM_SUPPORT_PATH'] + '/lib/ui'

choices = OSX::PropertyList.load(File.read(ENV['TM_BUNDLE_SUPPORT'] + '/functions.plist'))
TextMate::UI.complete(choices, :initial_filter => ENV['TM_CURRENT_WORD'], :extra_chars => '_')

It turns out TextMate has built-in support for this menu-based code completion UI in its ui.rb support file — and it works pretty darn well. The completions are stored in the referenced plist file, whose structure is pretty self-explanatory:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array>
    <dict>
        <key>display</key>
        <string>ArrayMin</string>
        <key>insert</key>
        <string>(${1:const variant &amp; src[]}, ${2:unsigned int idx}, ${3:unsigned int len})</string>
    </dict>
</array>
</plist>

The value of the display key contains the name of the code completion item as it will appear in the list. Additionally, the value of the insert key contains an ordered list of parameters, which will be inserted whenever a code completion is accepted.

By leveraging this, I managed to add menu-based code completion support to a NXC bundle I’m working on, all in a matter of minutes. It’s a shame that so few TextMate bundles utilize this hidden gem.

AppKit Quick Tip: Populating the 'Open Recent' Menu in Non-Document-based Applications

Sat, 09 Jul 2011 17:17:59 -0500

While writing Nibble, my native Apple I emulator for Mac OS X and iOS, I realized an Open Recent menu would be beneficial to users who want to quickly open recently-loaded memory dumps. In standard Document-based applications, AppKit automatically registers newly-opened files as recents. Unfortunately, it doesn’t make much sense to make an emulator a Document-based application.

Luckily, even Non-Document-based applications contain an Open Recent menu, ready to be populated. Moreover, NSDocumentController makes it extremely easy to register recently-accessed files through its noteNewRecentDocumentURL: method. AppKit will magically append the file at the passed URL to the Open Recent menu; it will even enable the Clear Menu item when necessary! When the user selects a recent file, AppKit will invoke the application:openFile: method on NSApplication’s delegate object.

The complete code listing can be found below:

NSDocumentController *dc = [NSDocumentController sharedDocumentController];
[dc noteNewRecentDocumentURL:[NSURL fileURLWithPath:somePath]];


- (BOOL)application:(NSApplication *)sender
           openFile:(NSString *)filename {

    // load the file

    return YES;
}

Enabling VNC on a Mac with a Broken Display

Sat, 09 Jul 2011 13:17:51 -0500

Around two weeks ago, my iMac’s display started turning itself off at random times. I thought this was a software bug as I was running the latest beta of Mac OS X, so I ignored the issue. Doing a quick restart always restored everything to normal. A few days later, the display wouldn’t turn on at all. The Mac would still run and I could hear Alex speak the time every half hour. I ended up ordering one of the latest quad-core, 27” iMacs, but I still wanted to get some work done before it arrived.

If I could enable screen sharing, I would be able to work from my Ubuntu box via VNC. So I hit ⌘-Space bar to bring up the Spotlight search box on the iMac. I typed Terminal and hit ‘Return’, all while staring at a pitch-black screen. To check on the state of things, I would periodically pipe the output of commands to the say command, which would in turn speak the input. For example,

pwd | say

would speak the path of the current working directory. Next, I enabled ARDAgent to start the screen sharing agent (normally enabled in System Preferences):

cd /System/Library/CoreServices/RemoteManagement
sudo ./ARDAgent.app/Contents/Resources/kickstart \
-activate -configure -access -on -clientopts -setvnclegacy -vnclegacy yes \
-clientopts -setvncpw -vncpw PASSWORD -restart -agent -privs -all

After a quick reboot, I was able to start a VNC connection from Ubuntu 10.10 to Snow Leopard. Of course, if you have another Intel Mac and a spare FireWire cable in the house, you can always boot up the defective Mac using Target Disk Mode.

All in all, I still managed to crank out a few more Xcode builds of some of the projects I’m working on, until my new iMac arrived.

AppKit Quick Tip: Highlighting an Entire NSTableView When Dragged Over

Fri, 01 Jul 2011 22:06:15 -0500

When a user drags any form of data onto a NSTableView configured as a drop destination, the data can be dropped above or on top of any row. Sometimes, it may be preferable to highlight the entire table when a drag enters its bounds, as shown below.

To accomplish this, set your drop row to -1 in the tableView:validateDrop:proposedRow:proposedDropOperation: method, which is a part of the NSTableViewDataSource protocol.

- (NSDragOperation)tableView:(NSTableView *)tableView
                validateDrop:(id < NSDraggingInfo >)info
                 proposedRow:(NSInteger)row
       proposedDropOperation:(NSTableViewDropOperation)dropOperation {

    [tableView setDropRow:-1 dropOperation:NSTableViewDropOn];

    return NSDragOperationEvery;
}

App Engine Notes

Fri, 01 Jul 2011 20:27:19 -0500

Earlier today, I released fb2cal, a web app that lets users view their Facebook friends’ birthdays right from a native calendaring client. Coming from a desktop development background, writing a web app on top of App Engine was a new experience for me. Some points to take away:

Extend templates to reuse large parts of common HTML code; think inheritance
Leverage the memcache when making large data store queries or performing network requests
To serve parts of a web app using HTTPS, add secure: always to the script handler in app.yaml

And lastly, to handle basic authentication in a subclass of RequestHandler:

auth = self.request.headers.get('Authorization')

if not auth:
    self.response.set_status(401, message="Authorization Required")
    self.response.headers['WWW-Authenticate'] = 'Basic realm="Secure Area"'
    return None

parts = auth.split(' ')
username_pass = base64.b64decode(parts[1]).split(':')

username = username_pass[0]
password = username_pass[1]

# validate username and password...

Overall, I was extremely pleased with how fast, easy, and inexpensive it is to host a fully-functional web app on App Engine.

Quick and Dirty Profiling with Blocks

Fri, 01 Jul 2011 20:21:59 -0500

Instruments is an amazing tool for finding all sorts of performance issues in your applications, but sometimes, all you want to do is log a quick and dirty timing of a snippet of code.

Mark Darlymple once posted a quickie that does just this. Unfortunately, the code isn’t very reusable. Each time you want to profile a chunk of code, you need to wrap it in nearly 8 lines of boilerplate code.

By writing a profile function that takes a block of work as an argument, this problem becomes trivial.

void profile (const char *name, void (^work) (void)) {
    struct timeval start, end;
    gettimeofday (&start, NULL);

    work();

    gettimeofday (&end, NULL);

    double fstart = (start.tv_sec * 1000000.0 + start.tv_usec) / 1000000.0;
    double fend = (end.tv_sec * 1000000.0 + end.tv_usec) / 1000000.0;

    printf("%s took %f seconds", name, fend - fstart);
}

To profile some code, all we now have to do is call profile and pass our worker block; the timing will get logged to standard out.

profile("Long Task", ^{ performLongTask() } );

App Store Review Guidelines

Fri, 01 Jul 2011 20:18:04 -0500

App Store Review Guidelines:

The App Store Review Guidelines and the newly-established App Review Board are huge steps in the right direction. Thank you, Apple.

Update: The introduction seems to be written by Steve Jobs himself, as others already pointed out.

We have over 250,000 apps in the App Store. We don’t need any more Fart apps. If your app doesn’t do something useful or provide some form of lasting entertainment, it may not be accepted.

Writing a Bouncing Ball Physics Simulation for iOS

Sat, 21 May 2011 12:53:00 -0500

Recently, I have been doing some iOS game development on top of the Chipmunk physics engine. Chipmunk is an exceptionally well-designed library which makes coding some basic physics simulations really fun. The goal of this article is to introduce you to the basics of Chipmunk while creating a bouncing ball physics simulation for iOS. When you tap on your device’s screen, a new ball will be added to the scene. As you tilt your device, all of the balls will fall in respect to the new gravitational field, reported by the accelerometer.

Getting Started

To get started, create a new Xcode project based off of the ‘View-based Application’ template. Select ‘iPad’ for the target device to get the greatest amount screen real estate. Name the new project “BounceyBalls”.

Next, we need to download the latest release of the Chipmunk physics library, found here. Extract the downloaded archive and drag the src and include subfolders into the Classes group of your Xcode project. Select “Copy items into destination group’s folder (if needed)” if it is unchecked and hit “Add”.

If we were to build the project, we would get a ton of build errors at this point. We need to tell Xcode where Chipmunk’s include files reside. To do so, select the Xcode project in the file navigator. Click on the ‘BounceyBalls’ target and switch to the ‘Build Settings’ tab. Find the ‘Header Search Paths’ setting and edit its value to include the path Classes/include/chipmunk. Compiling the Xcode project should now yield no build errors or warnings.

Since we will be using Core Animation in this project, we also need to make sure the product gets linked against the QuartzCore framework. Right-click on the Frameworks group, select Add > Existing Framework, and choose QuartzCore.framework from the list.

Chipmunk Overview

Before we dive into the code, let’s review some basic information about Chipmunk. Chipmunk is a fast and portable 2D physics engine written in C and distributed under the MIT license. It is a nice and lightweight alternative to the heftier Box2D library (written in C++). Even though the Chipmunk library comes with a simple API, it also includes support for advanced features such as joints, collision detection handlers, and queries. While I don’t cover them in this article, they are well-documented on the Chipmunk website. Chipmunk also includes functions for performing common operations with vectors.

The three fundamental concepts used in Chipmunk are spaces, bodies, and shapes.

A space is the “world” in which the physics simulation takes place - it serves as the container for bodies and shapes.
A body is any object that has a mass and a position in space. Chipmunk supports both dynamic bodies and static bodies. As their names imply, dynamic bodies are capable of movement while static bodies, such as the ground, are not.
A shape defines how a body interacts with other bodies, especially during collisions. It can take the form of a circle, segment, or polygon.

Writing the Simulation

Let’s dive into the code. Replace the contents of the BounceyBallsViewController.h file with the code below.

#import "chipmunk.h"
#import <QuartzCore/QuartzCore.h>

@interface BounceyBallsViewController : UIViewController
            < UIAccelerometerDelegate > {

    cpSpace *space;
}

@end

The code above should be fairly straightforward. We import the necessary header files, configure our view controller so it conforms to the UIAccelerometerDelegate protocol, and declare a pointer to a cpSpace, which serves as the container for all of the objects in the simulation.

Now, let’s switch over to the BouncingBallsViewController.m file. We will define a method, setupSpace, which configures the “world” for our physics simulation.

#define GRAVITY 400.0f

- (void)setupSpace {
    cpInitChipmunk();

    space = cpSpaceNew();
    space->elasticIterations = space->iterations;
    space->gravity = cpv(0.0f, GRAVITY);

    CGSize size = [[self view] bounds].size;

    cpBody *edge = cpBodyNewStatic();
    cpShape *shape = NULL;

    // left
    shape = cpSegmentShapeNew(edge, cpvzero, cpv(0.0f, size.height), 0.0f);
    shape->u = 0.1f;
    shape->e = 0.7f;
    cpSpaceAddStaticShape(space, shape);

    // top
    shape = cpSegmentShapeNew(edge, cpvzero, cpv(size.width, 0.0f), 0.0f);
    shape->u = 0.1f;
    shape->e = 0.7f;
    cpSpaceAddStaticShape(space, shape);

    // right
    shape = cpSegmentShapeNew(edge, cpv(size.width, 0.0f),
                              cpv(size.width, size.height), 0.0f);
    shape->u = 0.1f;
    shape->e = 0.7f;
    cpSpaceAddStaticShape(space, shape);

    // bottom
    shape = cpSegmentShapeNew(edge, cpv(0.0f, size.height),
                                    cpv(size.width, size.height), 0.0f);
    shape->u = 0.1f;
    shape->e = 0.7f;
    cpSpaceAddStaticShape(space, shape);
}

First, we initialize the Chipmunk library. Without this, Chipmunk will, quite simply, crash. Then we initialize our simulation’s space and set its initial gravitational vector. Next, we need to define the “edges” of our viewport to prevent objects from moving off-screen. We create a new static body as well as four segment shapes, which correspond to the four edges of the screen. The u field of the shape structure defines the friction coefficient (which ranges from 0.0 to 1.0). The e field defines the coefficient of restitution (or quite simply, bounciness, between 0.0 to 1.0). It is best to experiment with these values to find one which feels natural. Once each static shape is set up, we add it to our space.

While we’re at it, let’s also implement dealloc before we forget:

- (void)dealloc {
    cpSpaceFree(space);
    [super dealloc];
}

Next, we will implement the viewDidLoad method and override shouldAutorotateToInterfaceOrientation to return NO, like so:

- (void)viewDidLoad {
    [super viewDidLoad];
    [self setupSpace];

    UITapGestureRecognizer *gr = [[UITapGestureRecognizer alloc] initWithTarget:self
                                                                         action:@selector(tap:)];

    [self.view addGestureRecognizer:gr];
    [gr release];
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)orientation {
    return NO;
}

In the code above, we setup our Chipmunk world and attach a gesture recognizer to our view. When a tap occurs, we will add a new ball to the simulation. Since we initially set up the gravitational vector, the ball will drop to the ground and bounce off of one of the four edges we defined. To learn more about gesture recognizers, consult Apple’s documentation.

Now, let’s implement the dropBallAtPoint: method, which will get called whenever the user taps on the screen.

#define RADIUS 32.0f

- (void)dropBallAtPoint:(CGPoint)pt {
    CALayer *layer = [CALayer layer];
    layer.position = pt;
    layer.bounds = CGRectMake(0.0f, 0.0f, RADIUS*2, RADIUS*2);
    layer.cornerRadius = RADIUS;
    layer.backgroundColor = [UIColor purpleColor].CGColor;

    [[self.view layer] addSublayer:layer];

    cpBody *body = cpBodyNew(1.0f, INFINITY);
    body->p = pt;
    cpSpaceAddBody(space, body);

    cpShape *ball = cpCircleShapeNew(body, RADIUS, cpvzero);
    ball->data = layer;
    ball->e = 0.7f;
    cpSpaceAddShape(space, ball);
}

- (void)tap:(UITapGestureRecognizer *)gr {
    CGPoint pt = [gr locationInView:self.view];
    [self dropBallAtPoint:pt];
}

We create a new Core Animation layer, which will represent our ball. Note that setting cornerRadius to half of the layer’s width will result in a circle shape. Next, we create a new dynamic body which will define the mass and position of the ball in space. Its center position corresponds to the layer’s center position. We also create a circle shape model object which corresponds to our layer’s shape. This will allow Chipumunk to perform collision detection against any other object in space. Finally, we associate the Core Animation layer with the shape for future reference, give the ball some bounciness, and add the shape to our space.

In order to run the actual simulation, we need to set up a timer which will periodically tell Chipmunk to update its bodies’ positions in space. We also configure the accelerometer in the viewDidAppear: method:

#define STEP_INTERVAL 1/60.0f

- (void)viewDidAppear:(BOOL)animated {
    [NSTimer scheduledTimerWithTimeInterval:STEP_INTERVAL
                                     target:self
                                   selector:@selector(step)
                                   userInfo:nil
                                    repeats:YES];

    [UIAccelerometer sharedAccelerometer].updateInterval = 1/30.0f;
    [UIAccelerometer sharedAccelerometer].delegate = self;
}

In the step method which we will implement next, we tell Chipmunk to step the simulation forward in time. It is optimal to use a fixed interval here. We also loop through every active shape in space by calling cpSpaceHashEach and update each ball’s position. Note that we disable the default Core Animation actions beforehand.

- (void)step {
    cpSpaceStep(space, STEP_INTERVAL);

    [CATransaction setDisableActions:YES];
    cpSpaceHashEach(space->activeShapes, &updateSpace, self);
    [CATransaction setDisableActions:NO];
}

static void updateSpace (void *obj, void *data) {
    cpShape *shape = (cpShape *) obj;
    CALayer *layer = shape->data;

    if (!layer)
        return;

    layer.position = shape->body->p;
}

Lastly, we will implement our accelerometer’s delegate method and adjust the gravitational field of our space. A low-pass filter is used to filter out random jerks.

#define FILTER_FACTOR 0.05f

- (void)accelerometer:(UIAccelerometer *)accelerometer
        didAccelerate:(UIAcceleration *)acceleration {

    static float prevX = 0.0f, prevY = 0.0f;

    prevX = (float) acceleration.x * FILTER_FACTOR + (1-FILTER_FACTOR) * prevX;
    prevY = (float) acceleration.y * FILTER_FACTOR + (1-FILTER_FACTOR) * prevY;

    space->gravity = cpv(prevX * GRAVITY, -prevY * GRAVITY);
}

That’s it! If you run the app on your iPad and add a few balls, you will notice they fall to the ground and bounce off. If you tilt the device, the balls will move since the gravitational field is adjusted.

The completed Xcode project can be found on github (updated).