Professional Documents
Culture Documents
DIGITAL
THINKERS
CONF.
LOS ANGELES
JUNE 1 - 2
Join top tech and design agencies to discover the
future of the web, make inspiring connections and
immerse yourself in the best talent of the digital
design community.
E-commerce
Site of the Year 2016
Protest
Sportswea
Protest
Sportswear
Build in Amsterdam
is an award winning design
and development shop.
Build in Amsterdam
Introduction
Sportswear brand Protest asked us to create a site that would
bridge the gap between story and store. They wanted to
combine an immersive brand experience with an incredible
eCommerce platform.
Woocommerce and Wordpress
We prefer working with Woocommerce and Wordpress, because
they enable the combination of storytelling and eCommerce in
one user friendly CMS system. Furthermore its an open source
platform, giving our clients the freedom to choose another
agency along the line. We want our clients to stay with us
because they want to, not because they have to.
Paper
Planes
Paper
Planes
Active Theory
is a creative digital production
studio based in Venice, California.
They focus on making polished
and innovative digital experiences
using web technology.
Paper Planes started as a simple thought - What if you could
throw a paper plane from one screen to another? After gradual
work and brainstorming, we shared the idea with our friends at
Droga5, who helped us bring it to the biggest possible stage:
Google I/O 2016.
like playfulness and relaxation. We used a blend of pink, blue Flocking is a complicated mathematical process that is tricky to
The earth was shaded with similar tones but we used specular
lighting and a teal rim glow to help distinguish it from the
background. The earth and sky were a constant mixing and
changing pair that needed to look good regardless of the earths
rotation or sky hue.
WebGL Text
Locations where planes
originate cycled through
during the event, creating an
impactful connection for people
around the world. We ran into
a bug on Chrome for Windows,
where no matter what we had
tried, compositing CSS text
animations onto WebGL incurred
a severe performance hit,
dropping our frame rate below
60 frames per second.
An added benefit was that text was entirely in the 3D get approximate geographic locations for stamps and Socket.IO
environment, allowing planes to occlude it as they flew into the to connect all devices over WebSockets, funneling messages to
experience! our graphics machine at I/O rendering the experience.
A WebSocket is a web technology that allows for a persistent Relay Server Relay Server Relay Server
socket connection between a web browser and a server. Once (Us-Central-1) (Us-East-1) (Europe)
The core of the network was the funnel server. All messages
were routed through the funnel before being displayed on the
GPU Desktop 1 GPU Desktop 2
50 foot screen on stage. Messages from attendees at I/O, both (Primary) (Backup)
paint splats and paper planes, were routed directly to the funnel.
To cater to the global audience, additional relay servers handled
connections from outside of the event location in Mountain
Google I/O Stage Display
View. Global participants were routed to the nearest relay
server based on their location. These relay servers would then
dispatch collections of messages to the funnel server. Relay Server, each with: 16 x CPU Cores - 16 x Socket Servers
32 x CPU Cores - 32 x Socket Servers
Hardware Software
This server infrastructure was setup using Compute Engine on The WebSocket servers were Linux VMs running multiple Node.
the Google Cloud Platform. js processes and Socket.IO servers on individual ports. The
number of threads scaled based on the number of CPU cores.
The main funnel server comprised 32 CPU cores, each serving Just like the client-side codebase, the servers also ran from
a dedicated Socket.IO server on its own thread and port. Relay a single codebase with custom modules and configurations
servers, each with 16 CPU cores, were set up in each Google set depending on each servers function and region. Code
Cloud Platform region around the world to create sub networks was deployed across all servers in one go, allowing for rapid
in us-central, us-east, asia-east, and europe-west. development and testing.
As connections were established, the server would register the Load Balancing
client, allowing each end to keep track of the other. In the case
Real time stats, including the number of concurrent connections
of an intermittent network failure, broken connections would
and average response times for each socket server, were
reconnect as soon as the network was restored. Each process
maintained for each WebSocket server. Tracking this data
could safely restart in just a few seconds, and all connections
allowed us to continually route new connections to the server
from mobile devices and screens to the server would be
with the greatest number of available connections.
automatically re-established without the user noticing.
From our load tests, we recognized that each relay server was
Outside of these servers, Google App Engine and Datastore were
capable of handling 16,000 concurrent socket connections
used to save and retrieve plane and stamp data. Google Cloud
safely without any performance drop. Triggers were in place
Storage was used to store all static assets.
to switch over to additional relay servers instantly if any server
reached the maximum number of concurrent connections.
Geolocation
Google App Engine provides approximate geolocation data
with each request header as a built-in service. This data, along Conclusion
with IP detection for known Google IP addresses, was used to With users participating from over 180 countries, the reception
determine if a user was at the event, or, if not, which city they
has been humbling. Extending an age old past time like paper
were connecting from.
plane throwing to connect people from all over the world
through a simple gesture was an amazing feeling.
With this location data, planes were caught, stamped and thrown
across the globe, waiting to be caught again. The city and country
location was stamped on the plane along the way. Paper Planes shows the power of the web through a simple
experience that connected strangers from all around the world.
In addition, there was no need to fiddle around with inputting
codes to establish the mobile to desktop connection. By
simply loading the experience on a phone or desktop, the user
connected right away to the same sub network based on their
location.
Experimental
Site of the Year 2016
Conqueror
Excellence
Conqueror of
Excellence
Your Majesty Co.
is a design and technology
firm based in New York and
Amsterdam that powers digital
product and brand experiences for
Netflix, adidas, Samsung, Spotify,
BMW, Coca-Cola, Universal Music
Group, Bentley, Absolut, American
Express and Red Bull.
Your Majestys culture is based on three principles: Chivalry,
Courtesy and Excellence. These arent just words for our
About Page. Theyre values that guide everything we do. The
Cavalier Project is an internal initiative we have created in order
to develop interactive experiences that combine our passion
for research and developmentstaying on top of emerging
technologywith our core principles.
The Game
Posture & Balance conveys a sense of knighthood in modern
daysthe pursuit of excellence. The trailer, poster and intro
of the game are all very dark and only show a light in the far
distance. Upon starting to play, the scenes slowly brightens. The
light becomes a goal to reach, just as Your Majesty constantly
reaches for excellence.
Process
We started with the story we wanted to tell. Then we used the
project as way to learn new technologies and improve the
capabilities of our agency. Our Art Director taught himself
Cinema 4D to create style frames as a base for the WebGL
development.
Animation
The trailer has a similar dark atmosphere as the game start
screen. Preparing for battle, creating tension and mystery,
by using close crops of the horse. Not showing too much so
theres something left to imagine.
Game World
The game world consists of two large procedurally generated
tiles. Whenever the player gets to the beginning of a new tile,
the previous tile is recycled, reconfigured, and placed beyond
the tile the player is now on. This process continues indefinitely.
Each tile has a grid layout with an inaccessible outer area and a stored object. This saves a lot of processing compared to
central path where nuggets and rising pillars are placed. In early doing bounding box intersection tests, and is still accurate (we
prototypes the tiles were populated randomly. However, this promise).
resulted in unpredictable and often undesirable patterns.
Later in the process we began curating the chaos by introducing Three.js & Shader Animation
a set of configurable rules. This gave us a number of key Posture & Balance is built on top of Three.js. This is the go-to
values we could use to control the difficulty and pacing of the framework for many WebGL projects, as it has a robust feature
gameplay. set and a great community. It also provides nice hooks if you
want to get closer to the hardware without having to manage
We wanted to prevent pillars from clumping up too much, all the nuts and bolts of the WebGL API. We used these to
and to make sure there was always a clear path through the create shader powered animations and post processing effects,
tile. To achieve this, pillars were spread out row by row using which played a big part in the overall aesthetic of the game.
randomized steps.
The pillars, nugget collisions, and the stretchy speed particles
We also wanted to make sure all the nuggets could be are all primarily animated on the GPU. They are set up as Buffer
collected. Their positioning is governed by a jagged line, never Geometries with custom Buffer Attributes. These attributes
placing more than one nugget on a row. After play testing we are used alongside uniforms in extended Phong and Basic
settled on a configuration where nuggets are never more than materials, where the animation state is calculated inside the
two lanes apart, which worked well with the sense of speed we vertex shader. This approach is similar to morph targets, but
wanted to achieve. instead of being linear, the interpolation is defined by arbitrary
logic.
The grid also removed the need to perform physical collision
detection. Instead, pillar and nugget positions are stored in a http://codepen.io/toreholmberg/pen/akKEEB
two dimensional array. As the player moves through the tile,
their position is converted into this array. Collision detection While harder to set up, this approach has huge performance
is done by checking if the player index overlaps with any benefits. The standard way of animating is updating the
transformation matrix of a mesh, and sending its 16 floats The first thing we changed was our HTML display stack. Initially,
to the GPU. As the number of objects increases, this quickly Three and Pixi each had their own HTML canvas. The Pixi
becomes a bottleneck, and rendering slows down. With our canvas was transparent, and lay on top. During the optimization
approach, all the data needed to calculate an animation state phase we decided to merge the two. Instead of being in the
is already in graphics memory. The animation state is then DOM, Three rendered into an off-screen canvas, which was
controlled by a handful of uniform values, which enables the used as a texture for a Pixi sprite.
GPU to crunch numbers undisturbed.
The next part of the optimization phase revolved around
http://codepen.io/toreholmberg/pen/JKkrrW reducing the draw count of Pixi. This is a property of the
WebGLRenderer that tells you how many separate drawing
After launching Posture & Balance we continued working on operations are performed each frame. Getting this number as
this animation system, which is now available as a Three.js low as possible is key to a smooth frame rate, as it reduces the
extension on GitHub (https://github.com/zadvorsky/three.bas). overhead from CPU to GPU communication.
The first thing we did was merge our textures into sprite
Interface & Performance sheets, one for regular and one for retina displays. This way
One of the main goals of this project was experimentation. WebGL textures do not need to be updated when rendering
To this end we decided to use Pixi.js for the interface layer. different objects. This helps Pixi to group objects into larger
We wanted to see how it would compare to traditional DOM batches which can be drawn simultaneously.
rendering. This approach resulted in some benefits, some
challenges, and a lot of learnings. Next we addressed text rendering. As it turns out, doing this
through Pixi is comparatively slow. Each time a string is
As we continued to add visual effects to the game, we started updated (like the score and time displays), the text is drawn
noticing performance issues. After some investigation, we were to an off-screen canvas, which is then send to the GPU as
surprised to find out this was primarily caused by the interface a texture. Excess traffic like this has a negative impact on
layer. We then set out to identify and eliminate as many performance. This could be addressed with Bitmap Fonts,
bottlenecks as possible. which effectively turn text into images that can be added to a
sprite sheet. However, this severely limits flexibility as Bitmap
Fonts scale very poorly. We opted to remove text from Pixi
altogether, rendering it in the DOM instead.
The final major bottleneck was the Pixi graphics api, which
we used to create some simple interface elements. The main
culprit here was the gallop indicator, which had about 60 parts.
With the graphics api, each piece demanded its own draw call.
We solved this by adding differently colored squares to our
sprite sheet. These were then scaled for the gallop indicator
and some other interface elements.
Debugging Tools
The Chrome debugging tools were invaluable in finding and
fixing these performance pain points. We used the Javascript
CPU Profiler to record performance during gameplay. Then we
examined the generated chart, looking for fat frames where
processing took longer than allotted.
KIKK
Festival
KIKK Dogstudio
Festival
is a design and technology
firm with offices in Belgium &
Chicago. We work with innovative
brands including Microsoft, The
Museum of Science And Industry
Of Chicago, The Kennedy Center
of Washington, Dragone, Quanta
Magazine. Since 2011 we have
been organising and designing
our own festival called the KIKK
Festival, which attracts over
10.000 people for two days
of conferences, workshops,
exhibitions, parties etc.
Building the website for the KIKK
Festival is always an exciting but
stress-generating time of the year for
us. Not only is it a great opportunity
to create something entirely new
based on the current years theme
for the festival, but there are also
expectations to deliver an experience
worthy of the escalating fame of the
festival.
Technical Approaches
For the KIKK Festival website, we use
a dedicated server in partnership
with our hosting partner cBlue who
provide a great SLA for our servers.
With this infrastructure we can ensure
high scalability during the Buzz
time of the website. For the server
architecture we use a LEMP stack
(Linux NginX MariaDB and PHP)
completed by a varnish server that
brings a speedy caching system.
Falter
Inferno
Falter
Inferno
Wild
is an award winning interactive
agency based in Vienna.They
focus on conception, design
and development of innovative
campaigns, websites and apps.
For Falters Inferno, everything started with the already completed
30 second TV spot. Our main challenge was to bring the amazing
illustrations alive interactively. In addition our goal was to create
a really smooth experience both on Desktop and Mobile.
16. attribute vec3 position; 40. mvPosition.xyz += normalize(cross(clampVel,vec3(0.0, 0.0, -1.0))) * vUV.y *
Resume
Falters Inferno was one of our longer ongoing projects, taking
roughly 2.5 months from kick-off to completion. We spent a lot
of time on tweaking animations and making the performance
great on mobile. We also had some amazing illustrations to
work with. After all we think the effort did pay off, and hope you
like the experience :)
Technologies
FRONTEND: WebGL / Three.js - JavaScript
SERVER: Amazon s3
A Sprite-Sheet for Falters Inferno, with some animations baked into separate
color channels to save space
Agency
of the Year 2016
Sound
in Color
Sound in
Color
Resn
is a creative digital agency.
We infect minds with gooey
interactive experiences and
saturate the internet with digital
miracles.
Discovery
The challenge for this HP Spectre campaign was to create a
unique piece of artwork from each unique sound source. An
artwork that did not look computer generated, something you
would deem wall-worthy.
From the original tube of paint to the final color applied to the
canvas a painter will use a palette of many to adjust the color
to the right tone.
We replicated that process. The color tubes would be our input
color frequencies then we combine them in order to represent
the sound as a whole.
Step 1: Obtain the artwork colors from the Step 3: Using the recording to create brush
sound frequencies of the recording. strokes and texture.
Technical Approach
We came up with a two step process to create the final Each individual brush was used as a texture on a plane that gets
artworks. the motion and the transformation in relation to the frequency
of the sound. We ended up with a maximum of 20 of those
planes at a time to not overkill the performance.
To get the colors right and harmonic we used the HSB color
space. HSB stands for hue, saturation and brightness and it is
more intuitive than RGB. It helps us to get the right spectrum
of colors based on the frequencies and makes it easier to keep
the contrast and the luminosity consistent by only offsetting the
hue. Tints that are close to blue represented low frequencies
whilst tints that go towards yellow were for higher frequencies.
Those colors are then used as a tint base for the brushes that
are being displayed.
Brush 05
Site Design & Art Direction
Artwork