Stephen Jenks

For several versions, Hiperwall software has offered a web-based External Interface (hereafter called the API) that allows external programs, including web browsers (yes, including Safari on iPad and iPhone) to open content and environments, close content, clear the display wall, etc. The Hiperwall 2.0 software added the ability to assign position and attributes to specific content as it is opened and to shutdown or sleep the wall (and wake it afterwards).

Hiperwall 3.0 adds an XML-based API that provides significant enhancements, including the ability to animate objects through sequences of commands that can change position, rotation, and visual effects, such as transparency and color filters. New abilities to query the size of display walls and specifications of available objects make it possible to write an application that can tailor itself to a display wall, even if that wall is comprised of multiple sub-walls distributed throughout a facility. These powerful API capabilities are similar to the new animation capabilities built into Hiperwall 3.0, an example of which is shown below, but even more flexible, since the API can be completely dynamic. The API turns a Hiperwall system into a giant sprite-drawing canvas where the sprites can be images, movies, live data feeds, streaming videos, or slideshows of any of them.

These new API capabilities are so powerful that I decided to write an example that showed just how dynamic Hiperwall content can be. Sure, a program like a slideshow or something similar would be pretty, but we already support slideshows natively, so I needed to come up with something really dynamic that demonstrates the ability to maintain control over a very energetic animation. I chose to write a Pong-like game called HiperPong. (My initial thought was Space Invaders, but I chose to simplify the idea to Pong because I want the program to be an example for our customers that want to use the API). This article explains the concept of operations for HiperPong, but does not provide code or documentation of the API. The source code and API documentation will only be available to Hiperwall customers via their authorized dealers once Hiperwall 3.0 is released, so please don’t request them from me.

HiperPong is a small Java program that runs on a networked computer (I’ve only tested it on Windows, but it should work on Mac or Linux). The UI is minimalist, as shown below. Since the program doesn’t have to run on the Hiperwall Control Node, a box at the bottom allows the user to type the hostname or IP address of the Control Node. The program then connects to the Control Node and queries the display wall dimensions, allowing the user to choose to play on a specific wall or all the displays together. It also queries the available content objects, and allows the user to choose objects for the two paddles and the ball. While the defaults look nice, you can make the ball a live video from a webcam or capture device, for example. There are two options to choose: whether to clear the wall when starting (so you can play the game over top of existing content running on the wall or not) and whether to have the program play by itself (otherwise the A and Z keys move the left paddle and the / and ‘ keys move the right paddle).

Once the user clicks the Start Button, the PlayingField code draws the center line down the middle of the wall and the left and right paddles, as well as the initial 0 and 0 scores. It does so by creating a Drawable object for each of them. Drawable is a class included in the HiperPong example code that maintains the state of a single object and allows the user to show the object on the wall and then animate it, and finally close it when it is no longer needed. The program makes the XML code to create the objects in the specified positions, and then uses an HTTP POST operation to send the commands to the Hiperwall Control Node. Each object is given a name (specified by the HiperPong program using a unique ID generator) at creation time. That name is then used by the program to modify the state of the object via the API. In this way, user programs can use their own mnemonic object names rather than having Hiperwall force names upon them.

After the playing field is created, the Game code starts a periodic task that runs 30 times per second. Each period, that task checks the status of the keys (if not auto-playing), sends commands to move the paddles, if appropriate, checks whether the position of the ball collides with the top and bottom walls of the playing field, checks if the ball is contacting the paddles, checks if the ball is out of bounds (scoring a point for one of the players), and sending a command to move the ball. The movement commands are not instant move commands, which would appear jerky, but use the Hiperwall software’s ability to interpolate movement, rotation, and other effects between the current state and the new state over a specified period of time. This allows smoother animations without having to manage at too fine-grain a level. The ball changes angle if it hits near the upper or lower edges of the paddles, and when the ball is hit by a moving paddle, the paddle imparts some spin onto the ball, which is causes the ball to rotate as it moves. If a score occurs, the old score value is commanded to appear to fly away by shrinking and becoming transparent while rotating 180 degrees, while the new score zooms into position from a very large and partially transparent starting position. The ball then resets to the center, blinks a few times, and then starts moving at a random angle. The game ends when one side gets 9 points, simply because I only made numbers from 0 to 9 as images that I imported to the display wall. A video showing HiperPong autoplay is below.

The HiperPong code shows how networked programs can use the Hiperwall API to create and manage very dynamic content on a Hiperwall display wall system. The API allows such code to create a named object, show it in a specified location with specified appearance effects, then animate it using absolute or relative movement and rotation as well as change the appearance over time. The HiperPong code shows how multiple XML commands can be combined into a single HTTP POST operation for efficiency. The code provides examples that can be used by Hiperwall customers to make their Hiperwall into powerful digital signage or advanced monitoring systems that can dynamically show events when they occur. These new capabilities to command the system over the network mean Hiperwall systems can be flexible, beautiful, and extremely useful with simple software using the API. Though HiperPong is written in Java, the API can be used by anything from Objective C to Python and anything that can make HTTP calls and process simple XML.

The Hiperwall 3.0 software is in Beta test at the time of this writing and will be shown at Infocomm in Las Vegas in June.