Advanced graphics are a big part of the web these days, but there are a couple of different renderers in the mix. You could use canvas, of course; but SVG and WebGL are also options. In this tutorial, we’ll review a relatively new drawing library, two.js, which provides one API that does the same thing with all three of those renderers. If you're ready, let's check it out!

Step 1 – Setting Up

The first step is to create a two instance and put it on the page. The Two contstructor takes an object with a number of parameters:

    var two = new Two({
           fullscreen: true 
        });
    

In this case, we're using the fullscreen option, which makes the drawing area take up the entire browser window. If we wanted our drawing area to have a specific size, we could use the width and height properties instead; these both take a number for a pixel value. There's also the autostart parameter; if this is set to true, any animations will run right away when the page is loaded.

There's also the type parameter: this decides which renderer will be used. You can choose between canvas, SVG, and WebGl. You don't just type the name, though: you use a library constant of sorts: either Two.Types.canvas, Two.Types.svg, or Two.Types.webgl. Just to be clear, two.js will just default to using SVG; it doesn't do any kind of feature detection to see what the browser will support. You'll have to do that on your own (and I think that's a good idea: small tools, one thing well, and all that).

So, once we have a Two instance, what do we do with it. First, you'll want to append it to the page. It has an appendTo method that takes an HTML element as a paramter, so let's set this up:

<div id="main"></div>
    <script src="./two.min.js"></script>
    <script src="./main.js"></script>
    

Then, in main.js, we start with this:

var el = document.getElementById("main"),
        two = new Two({ 
            fullscreen: true
        });
    
    two.appendTo(el);
    

With all this set up, we're ready to actually draw a few shapes.

Step 2 – Drawing Basic Shapes

We'll begin with basic shapes; while we can create our own complex shapes with new Two.Polygon, most simple shapes can be made with a few handy methods.

Let's start with circles. The makeCircle function takes three parameters:

var circle = two.makeCircle(110, 110, 100);
    circle.fill = "#881111";
    
    two.update();
    

We’ll review from the bottom, up: the call to two.update updates are drawing area and actually renders the content. Backing up to the circle, the first two parameters are the x and y coordinates for the center of the circle. Then, the third parameter is the radius for the circle. All the two.make... functions return a Two.Polygon object. As we go through this tutorial, you'll see several properties and methods that you can use on these shapes. Here's the first: fill. As you might guess, it sets the fill color: any valid CSS will do.

The result should look like this:

Now, what about rectangles? The two.makeRectangle method takes four parameters. Just like the circle, the first two parameters mark the x and y coordinates for the center of the rectangle. Then, param three is width and param four is the height of the rectangle.

var rect = two.makeRectangle(115, 90, 150, 100);
    rect.fill = "orange";
    rect.opacity = 0.25;
    rect.noStroke();
    
    two.update();
    

Again, we're using the fill property. We're also using the opacity property, which accepts a decimal value between 0 and 1; we're got quarter-opacity here. Finally, we're using the noStroke method, which removes the stroke (border) from the rectangle. Here's what we have:

Ellipses are pretty simple, too: as you might guess, the first two parameters set the center of the ellipse. Then, we've got width and height:

var ellipse = two.makeEllipse(100, 40, 90, 30);
    ellipse.stroke = "#112233";
    ellipse.linewidth = 5;
    ellipse.noFill();
    
    two.update();
    

For new properties: we've got stroke, which sets the color of the border; to set the width of that border, we use the linewidth property. Then, remember noStroke? The noFill method is the same, except removes the fill color for our shape (without that, our shapes default to a white fill).

Of course, the simplest shapes are lines.

var line = two.makeLine(10, 10, 110, 210);
    line.linewidth = 10;
    line.stroke = "rgba(255, 0, 0, 0.5)";
    

The first two parameters are the x and y for one end of the line; the second set are for the other end.

Probably the most awkward shape to create is the curve. The two.makeCurve method takes as many sets of x, y parameters as you'd like – each pair being a point where the line will curve. Then, the last parameter is a boolean: make it true if the shape is open, meaning the ends don't connect. If you'd like two.js to draw a line connecting the two ends of the curves, that should be false.

var curve = two.makeCurve(110, 100, 120, 50, 140, 150, 160, 50, 180, 150, 190, 100, true);
    curve.linewidth = 2;
    curve.scale = 1.75;
    curve.rotation = Math.PI / 2; // Quarter-turn
    curve.noFill();
    

You know linewidth, but what about scale? We can use this to shrink or expand our shape; here, we're expanding the shape by 175%. Then, we can use rotation to rotate our shape by a number of radians; we're doing 90 degrees, which is half-PI radians.

Finally, you might think that since we've made shape open, we won't get a fill; but that's not true. An unclosed curve will still have a fill, so we're using noFill to remove the fill and end up with just the curve.

The last shape type is the catch-all: it's the general polygon. Actually, it's pretty much just like the curve, except the lines go straight from point to point.

var poly = two.makePolygon(110, 100, 120, 50, 140, 150, 160, 50, 180, 150, 190, 100);
    poly.linewidth = 4;
    poly.translation = new Two.Vector(60, 60);
    poly.stroke = "#cccccc";
    poly.fill = "#ececec";
    

As with the curve, we have as many pairs of coordinates as we'd like, and then the open boolean; here we're setting it to false, so the shape will be closed.

We're also setting a translation here; this allows us move the shape left or right and up or down. We're setting the translation property to a Two.Vector instance. The Two.Vector constructor takes two parameters: an x and a y. These end up being the coordinates for the center of the shape. You don't actually have to create a new vector for this; you can just assign the x and y values directory:

poly.translation.x = 60;
    poly.translation.y = 60;
    

Here's what we get:

Step 3 – Making Groups

So far, we've been working with individual shape objects; however, it's possble to group shapes together and interact with them as one piece.

You can make a group with the two.makeGroup method. Then, we can use its add method to add a shape to the group.

var group = two.makeGroup(),
        rect = two.makeRectangle(0, 0, 100, 100),
        circ = two.makeCircle(50, 50, 50);</p>
    
    rect.fill = "red";
    circ.fill = "blue";
    
    group.add(rect);
    group.add(circ);
    
    two.update();
    

If you run this, it's pretty basic; just like you'd get without the group bits.

But then, we can work with the group, using any of the transformations we can do on an individual shape. For example, how about a translation?

group.translation.x = 100;
    group.translation.y = 100;
    
    two.update();
    

As with regular shapes, groups are ordered from back-to-front as they are created. However, if you add a shape to one group, and then another group, it will be removed from the first group. This is great if you need to change the front-to-back order of the shapes when animating (which we'll get to). So, if we start with this:

var topGroup = two.makeGroup(),
        bottomGroup = two.makeGroup(),
        rect = two.makeRectangle(100, 100, 100, 100),
        circ = two.makeCircle(150, 150, 50);
    rect.fill = "red";
    circ.fill = "blue";
    
    topGroup.add(rect);
    topGroup.add(circ);  
    
    two.update();
    

We have the same as above:

But, if we add the rect to the bottomGroup instead . . .

bottomGroup.add(rect);
    

Now, our square is on the top.

Step 4 – Animating Shapes

Finally, let's talk about animation. You already know that two.js renders the shapes you've created when you you call two.update(). If you call two.play() instead, it's like calling update() repeatedly, using Request Animation Frame. Each time this happens, two.js fires an “update” event. This is how we can produce animation: listen for the “update” event; and when it happens, run a function to set up the next frame.

Our examples so far have been rather simple, so let's step things up a notch: We’ll create an orbiting planet with its own orbiting moon. Remember, we start by creating two instance:

var el = document.getElementById("main"),
        two = new Two({ 
            fullscreen: true
        }).appendTo(el);
    

Next, we need to set up a few variables.

var earthAngle = 0,
        moonAngle  = 0,
        distance   = 30,
        radius     = 50,
        padding    = 100,
        orbit      = 200,
        offset     = orbit + padding,
        orbits     = two.makeGroup();
    

We'll increment earthAngle and moonAngle to get our planet and moon around their orbits. The distance variable is how far our moon will be from our earth. The radius is the raduis of our planet earth, and the padding is how much space our planet will have outside its orbit. Said orbit comes from the orbit variable. The offset variable is how far our planet will be offset from the edge of the canvas. Finally, the orbits group will hold the two orbit circles, which will allow us to show or hide them at will. Don't worry if you're a bit confused; you'll see how they all work together in a second.

We'll start with the earth's orbit line. Of course, that's just a simple circle:

var earthOrbit = two.makeCircle(offset, offset, orbit);
    earthOrbit.noFill();
    earthOrbit.linewidth = 4;
    earthOrbit.stroke = "#ccc";
    orbits.add(earthOrbit);
    
    two.update();
    

There's nothing new at all here. Here's what you should see:

Then, we need to create a planet and place it on its orbit. First, we need a means to figure out where on the orbit the planet should be placed; and of course, this needs to change for every animation frame. So, let's create a function that will return the center x and y coordinates for the orbit based on the current angle for positioning around the circle and the radius of the orbit:

function getPositions(angle, orbit) {
        return {
            x: Math.cos(angle * Math.PI / 180) * orbit,
            y: Math.sin(angle * Math.PI / 180) * orbit
        };
    }
    

Yes, it's a little bit of trigonometry, but don't worry too much: basically, we're converting the angle (which is a degree) to a radian, using the JavaScript sine and cosine methods, and then multipling it by the orbit. Now, we can use this function to add the earth to the picture:

var pos = getPositions(earthAngle++, orbit),
        earth = two.makeCircle(pos.x + offset, pos.y + offset, radius);
    
    earth.stroke = "#123456";
    earth.linewidth = 4;
    earth.fill = "#194878";
    

We start by getting the position for the first earthAngle (value of 0, remember?); then, we make our earth based on those positions (plus the offset) and color it up. Here's what we end up with:

Now, let's animate this planet. The event binding code actually comes straight from Backbone, so it might look familiar:

two.bind("update", function (frameCount) {
        var pos = getPositions(earthAngle++, orbit);
        earth.translation.x = pos.x + offset;
        earth.translation.y = pos.y + offset;
    });
    
    two.play();
    

What's happening here is that every time the update event occurs, we're using the getPositions function to calculate the position for the next angle on earth. Then, we just have to set the center of the earth to those new positions, plus the offset. Finally, we call two.play() to start the update events. If you reload the page now, you should see the earth rotating around the orbit.

Nice job so far, eh? Now, how about the moon and its orbit path; this will go above the bind statement.

var moonOrbit = two.makeCircle(earth.translation.x, earth.translation.y, radius + distance);
    moonOrbit.noFill();
    moonOrbit.linewidth = 4;
    moonOrbit.stroke = "#ccc";
    orbits.add(moonOrbit);
    
    var pos = getPositions(moonAngle, radius + distance), 
        moon = two.makeCircle(earth.translation.x + pos.x, earth.translation.y + pos.y, radius / 4);
    
    moonAngle += 5;
    moon.fill = "#474747";
    

This looks a lot like the code for the planet: we center the moon's orbit circle at the center of the earth using its translation properties; its radius is the radius of the earth plus the distance the moon should be away from the earth. Again, we add the moonOrbit to the orbits group.

Next, we create the moon, by first getting its desired position and creating a circle at that location. For a radius, we'll use a quarter of the radius we used for the earth. We'll be imcrementing the angle of the moon by 5 each time, so it will move faster than the earth.

Turning off the animation (by commenting out the two.bind statement), we get this:

Last step: get the moon animating. Inside that same two.bind statement, add these lines:

var moonPos = getPositions(moonAngle, radius + distance);
    moon.translation.x = earth.translation.x + moonPos.x;
    moon.translation.y = earth.translation.y + moonPos.y;
    moonAngle += 5;
    
    moonOrbit.translation.x = earth.translation.x;
    moonOrbit.translation.y = earth.translation.y;
    

Just like before, we get the new position for the moon, and position it relative to the earth. Then, we also move the moon's orbit ring so that it stays centered on the earth.

With all this in place, our little example is complete: Here's a still-shot of the action:

Like I said, we can also hide the orbits. Since they're both in the orbits group, we can use the visible property of the group:

orbits.visible = false;
    

And now:

Conclusion

Well, that's a wrap on this tutorial. Do you think you'll be using two.js in any of your own projects? Or maybe you have a better alternative? Let's hear about it in the comments!

The software that obliterated human champions on Jeopardy will now be talking to customers of banks and other companies through websites and mobile apps.

Watson, the IBM computer system that attracted millions of viewers when it defeated two Jeopardy champions handily in 2011, is finally going to meet its public.

With all of the different smartphones, tablets and other devices that sport various operating systems and versions thereof, a Web developer’s job — testing (sometimes virtually) on multiple devices to resolve errors — hasn’t become any simpler. This article suggests how we can manage these tasks without pouring a truck-load of money into actually buying all of these different devices.

A user tests his website on a Blackberry device and takes notes of bugs.

Do You Test On Actual Devices?

Whether you develop websites or apps, you face several problems in ensuring that a product runs correctly on as many devices as possible. Emulators for iOS, Android, Opera and the rest can help with that, but they differ from the software that runs on real devices. One of the things you just can’t simulate properly is touch interaction. Without being able to test gestures, there is no way to find out whether your users will understand how to use your interface. Because this is unlikely to change anytime soon, there is no way around testing on real devices.

While most developers probably have a smartphone and a tablet at home, two devices cover only a fraction of the types of devices and operating systems available — devices and operating systems that you should be testing your projects on. There are dozens of screen sizes, browsers and display types, and they make a huge difference when you’re fixing bugs in a responsive design. Despite your CSS and JavaScript being valid and well written, malfunctions on some mobile devices will occur simply because the variety of rendering engines haven’t been sufficiently standardized.

Testing touch gestures on different devices.

Some errors you would probably never notice because they appear only on devices that are uncommon in your country — but may be common in others. Thus, buying a lot of devices for testing seems to be an obvious solution. But that leads to two major problems: buying all of these devices would become very expensive (and you probably would not use them regularly anyway). Secondly, remote debugging on a wide variety of devices is not that simple. Fortunately, this has become much easier with all of the tools available today, but you still have to deal with it.

Crowd-Sourcing Makes Life Easier

This is where crowd-sourcing comes in. No one needs all of these devices every day. In fact, most developers need them only every few weeks.

Instead of every developer buying them all, what if there was a place where people could share devices for testing? If each person purchased a single device, you might already have enough to set up a device lab — which would save you a lot of money. The bigger the community of people contributing to this lab, the larger the variety of devices to test on. Even better, the community could even ask manufacturers to provide their devices to the lab, thus saving you even more money. Thus, access to mobile devices and a great testing space would be made available not just to you, but to everyone.

The Open Device Lab initiative aims to do just that. Currently, there are more than 50 locations around the world where a developer can go to test their project on multiple devices (some labs have more than 80 in stock). Most are completely free to use, while a few charge a small fee to cover the cost of running the lab. Because open device labs are meant to be non-profit, this is a fair deal and still much cheaper than buying the devices on your own.

A co-working space can be a nice surrounding for an Open Device Lab.

The people behind the labs range from individual developers who establish labs in their local co-working spaces to agencies that open their doors to share their hardware and knowledge with everyone. Different labs focus on different types of development: some on websites, some on apps, others on operating systems. Most have rules on using the lab. In general, you will want to make sure that installing your own software or wiping a device is OK.

Most sites cover a wide range of mobile manufacturers. In general, open device labs aim to supply at least the devices most used in their area. To check which devices are available in your area, search for a lab and check the list of manufacturers.

Many labs also provide development tools, such as Weinre, Adobe Edge Inspect, JS Console and Remote Preview, as well as platform-specific tools, such as the Safari Web Inspector. Remote inspection might be set up in some labs so that you can test and debug your websites from your computer, while some labs will have helper tools to enable you to test a product synchronously on all devices and debug individually. Each lab has its own features, so check to see whether the one near you meets your needs.

While Remote Preview will display a website on different devices, JS Console is just a remote console for your website. Weinre and Edge Inspect allow for remote inspection through a WebKit inspector and synchronized browsing, but they only run in the embedded Web view of the OS.

The labs also address Wi-Fi issues that occur with normal routers when more than an 40 devices are connected to the network. People have already solved problems that would normally drive you crazy, and they are happy to share their solution with you. And you can do the same by sharing your knowledge with others.

Many labs are built in existing co-working spaces, which makes it easy to maintain and access them. Another advantage of this is that you can schedule your time in the co-working space to coincide with when you will need to test extensively.

A user takes notes about viewing his website on a Blackberry.

Help Yourself And The Community

You can benefit a lot from such spaces. When you’re tackling a particularly tricky problem, the lab very likely has people who can assist you.

But make sure to help others when they ask for it. Developing websites together is much more fun and, from my experience, produces better results. And when you deliver great work, other people will notice and will consider hiring you for future work.

Support Open Device Labs

Because open device labs are built by the community for the community, it is very important that users give a little back. Doing this is rather simple. Most people have old devices at home. If you do and don’t need them anymore, consider donating them.

Secondly, offer some spare time to maintain a lab or at least spread the word among your colleagues. All of these little things help labs to grow, in turn helping developers like you all around the world.

The Open Device Labs website has a map of all existing labs. You can see how many devices are available and from which manufacturers, and you can read and give feedback on each lab. Thus, you can easily find a lab that fits your needs.

Viewing your product on various devices at one place makes it easy for you to identify problems.

Nonetheless, many more labs are needed around the world, as shown in the world map. The demand is worldwide, but many people don’t know that such labs exist or how easy starting one actually is. Labs flourish with enough supporters, and the more supporters in a region, the better a lab gets. So, help to build these spaces, and tell others about the movement.

An API enables easy access to information about all of the labs. To open up your own lab, the non-profit organization LabUp will support you by providing relevant information. You can easily build a website for your lab, and keep basic information about the lab up to date using the API. It is CORS- and JSONP-enabled, so you can access it right from your own domain. The documentation describes what kind of data you can access with the API and how to implement it on your website.

Create An Open Device Lab

Open device labs are a new movement, so you might not find one near you. But filling the gap is easy. Just search for colleagues in your region, connect with them, build the lab together, and move the Web forward! If you work at a company that owns a lot of devices, creating an open device lab is especially easy. But creating one wouldn’t be much harder for a freelancer. LabUp will be happy to help you establish a lab by giving you tips on setting up the technical aspects and by connecting you to device manufacturers.

If you’d like to spearhead a lab in your area, taking care of the following details will give you a good start:

• Make the space open and freely accessible.
• Create a pleasant interior so that people look forward to coming.
• Provide some devices at launch, and invite contributions or sponsorships.
• Make sure the Internet connection is fast and reliable.
• Build rock-solid Wi-Fi.
• Install stands for the devices.
• Secure the devices so that they don’t get stolen.
• Coordinate people to run the lab when it’s open. (And consider keeping it open for long hours).
• Find ways to reduce costs for you and the lab’s users.

In short, seriously consider creating, maintaining or supporting an open device lab in your area.

Open Device Labs often have a lot of different devices to test on.

More Resources

• LabUp!
• “Establishing an Open Device Lab,” Viljami Salminen, Smashing Magazine
• “How to Build a Device Lab” Dave Olsen
• Jay Meissner Articles on Jay’s blog related to open device labs

All images by Open Device Lab Nuremberg.

(al) (ea)

© Anselm Hannemann for Smashing Magazine, 2013.

Pulling a peanut butter and jelly, or ham and cheese on rye out of your lunchbox every day can get boring pretty quickly, but Evan and Kenny LaFerriere don’t have that common school-kid problem. Their dad, Massachusetts-based graphic designer David LaFerriere, has been illustrating their sandwich bags with colored Sharpies nearly every day since 2008.

What began as a creative outlet for David as he packed his kids’ lunches quickly turned into a morning tradition. Come noon-hour, the boys and their friends were tickled to find drawings of robots, monsters, Santa Claus, spectacle-wearing fish, and a multitude of other quirky characters adorning their sandwich baggies.

With approximately 1,100 drawings — most of which were photographed by LaFerriere — it’s clear that this Superdad isn’t short on inspiration. And since he plans to keep going until his kiddos go off to college, he’s going to need plenty of ideas — and a whole lot of Sharpies.

Which illustrations do you like best? Have you used your design talents to start fun traditions? Tell us in the comments.

Wallpaper Wizard for Mac (with 100,000+ Wallpapers) – only $4.97!

In this episode of The Treehouse Show, Nick Pettit (@nickrp) and Jason Seifer (@jseifer) talk about Reflections, Mobile Typography and Responsive Images.

Here are the links for the week:

BetterToggle jQuery Plugin
http://jquer.in/betterToggle-jquery-plugin/

Creating Realistic Reflections On Animated Glossy Elements
http://www.ryancollins.me/?p=404

Drawscript – convert Illustrator shapes into code
http://drawscri.pt/

Fullscreen Layout with Page Transitions | Codrops
http://tympanus.net/codrops/2013/04/23/fullscreen-layout-with-page-transitions/

How To Customize Your CSS Buttons With Pictogram Icons | DesignWoop
http://designwoop.com/2013/04/how-to-customize-your-css-buttons-with-pictogram-icons/

Typography in Mobile Design: Important Aspects and Examples – Designmodo
http://designmodo.com/mobile-design-typography/

estelle/clowncar · GitHub
http://github.com/estelle/clowncar

The Flattening of Design – NYTimes.com
http://bits.blogs.nytimes.com/2013/04/23/the-flattening-of-design/

The post Reflections, Mobile Typography and Responsive Images – Treehouse Show Ep 41 appeared first on Treehouse Blog.