This is a part of a beginning Processing tutorial series. If you’re new to Processing, start at the beginning!

As we continue our series on the basics of programming with Processing, we’ll look at extending the “Ball” class we created in the last set to include a user-controlled “Puck” object that can be used to turn this little app into a kind of air-hockey game. Fun stuff!

The beauty of working with object-oriented code is that we can extend the functionality of our code incredibly simply.

In this case, we’ll be creating a new type of Ball object called a “Puck”. All of the variables and methods that are defined in the Ball class will be available to our Puck class, but we’ll be able to add and tweak functionality as needed.

To download the full code on openProcessing.org!

Now that we’ve looked at the basics of the PVector object class, and even created some of our own objects, lets see if we can make the balls bounce off of one another! This will be the simplest 2D collision physics possible, with nothing extra whatsoever, and the math is surprisingly simple!

Grab the code from OpenProcessing!

I typically create PDF presentations using inDesign, but there are times when it’s more convenient to do it straight from Photoshop. Here’s a great little workflow for creating a PDF presentation from Photoshop, using a greatly under-used feature called ‘Layer Comps’.

The back of an iPad is a perfect example of the classic “crowned surface” frequently used in industrial design. We’ve seen it done in Rhino, so here I’ll demonstrate a method for creating a good-quality class-a surface in SolidWorks.

This is a part of a beginning Processing tutorial series. If you’re new to Processing, start at the beginning!

In the last set of tutorials, we looked at how to make a basic circle “bounce” around inside a processing window. In this set, we’ll introduce two new concepts that should help make this simple program more powerful and flexible: ‘PVector’, and ‘Objects’.

Vectors and Objects get a bad rap for being complicated. They get this reputation because they are often used to accomplish very complicated things, but at their root, both are extremely simple concepts, and every programmer should understand both.

First we’ll import the OpenGL library available within Processing. This will allow our sketch to run much more smoothly with graphics-heavy applications. In our case, we’ll be making a program with many–perhaps dozens–of bouncing balls. This may get too heavy to draw efficiently using processor power alone, so we’ll be relying on our graphics card to do the heavy lifting.

A ‘PVector’ (short for ‘Processing Vector’) is simply a way of accessing vector variables within processing. A vector is simply a way of storing multiple values in a single variable. For example, instead of using ‘xPosition’ and ‘yPosition’ in our program, we could just use a single vector object called ‘position’. To access the ‘x’ and ‘y’ components of the object, we simply call ‘position.x’ and ‘position.y’.

The beauty of a vector object is that there are various ‘methods’ that allow us to do math operations very quickly and efficiently. For example, instead of adding the x and y components of two vectors manually, we can simply use ‘position.add(velocity);’. This will help keep our code shorter, cleaner, and make life much easier when dealing with complex physics.

You can think of an “Object” like a little program within your larger processing sketch. In this case, we’ll be creating a ‘Ball’ class. Every ‘Ball’ object in our sketch will behave in exactly the same way, based on the same code we wrote in the last tutorial. The difference will be that we can create (or “instantiate”) as many Ball objects as we want, and they’ll each behave autonomously.

import processing.opengl.*;
ArrayList bouncyBalls;

void setup() {
size(720,400,OPENGL);
hint(ENABLE_OPENGL_4X_SMOOTH);

bouncyBalls = new ArrayList();

for(int i=0; i < 20; i++) {
bouncyBalls.add(new Ball(random(0,width),random(0,height),random(0,5),random(0,5)));
}
}

void draw() {
background(255);
for(int i=0; i < bouncyBalls.size(); i++) {
Ball theBall = (Ball) bouncyBalls.get(i);
theBall.update();
theBall.display();
}
}

class Ball {
PVector pos = new PVector();
PVector vel = new PVector();

Ball(float xPos, float yPos, float xVel, float yVel) {
pos.x = xPos;
pos.y = yPos;
vel.x = xVel;
vel.y = yVel;
}

void update() {
pos.add(vel);

if ( pos.y + 30 > height || pos.y – 30 < 0 ) {
vel.y *= -1;
}

if ( pos.x + 30 > width || pos.x – 30 < 0 ) {
vel.x *= -1;
}
}

void display() {
fill(0); noStroke();
ellipse(pos.x,pos.y,60,60);
}
}

SolidWorks Class 101: coffee maker – video 00 of 16 from Adam OHern on Vimeo.

SolidWorks has become one of the most ubiquitous CAD packages in the consumer product design industry. Its primary competitor is ProEngineer, though it belongs to an entire class of 3D packages called “parametric solid modelers”.

Though great strides have been made in recent years, most parametric CAD packages still have a steep learning curve. Each has its own advantages and weaknesses, but parametric CAD user interfaces are almost universally chunky, awkward, and inconsistent. SolidWorks is a rare exception to this rule. SolidWorks has significant limitations, but for most users it makes up for them in ease of use.

In this in-depth video tutorial series, we’ll get you up and running as an Industrial Designer in SolidWorks. The key to success in parametric modeling is to adhere religiously to the ‘KISS’ method, and in these videos I will demonstrate a wide variety of tools and techniques that will help to simplify your history tree and make updates more reliable and efficient.

We will be focusing on class-a surfacing methods that will help lead up to future projects with more challenging surfacing requirements. Many of the methods used here may seem strange to anyone accustomed to ‘solid’ based modeling. Fear not, solid lovers! There is a method to the madness.

The class is broken into three parts:

Part 1: Getting Started

Part 2: Building the Parts

Part 3: Details and Export

SolidWorks Class 101: coffee maker – video 01 of 16 from Adam OHern on Vimeo.

This post is a part of an extended video series covering the basics of SolidWorks. If you are new to this series, start here.

Part 1: Getting Started

• Video 01: User Interface Tour
• Video 02: the Carafe Revolve
• Video 03: the Pour Spout
• Video 04: the Carafe assembly component

Our goal for part 1 of our three part SolidWorks class will be to understand the user interface, and begin to understand the overarching workflow for construction. We’ll be build a ‘MasterForm’ document that will be the basis for all of the other parts in our assembly. Think of the MasterForm like an outline to a term paper: the goal isn’t to make detailed points and arguments, but rather to lay out the overarching scope of the paper in general but discreet terms. In the same way, our MasterForm part will have the basic planes and surfaces necessary in order to create our final parts, but nothing more.

Once we’ve created a surface in our MasterForm, we can import it into other parts to use as a basis for construction. This might seem like a long-handed way of working, but it pays dividends in the long run. Even with a relatively simple model like this one, our construction tree would be impossibly complex if we tried to work in a single part document. Using a master model allows us to break our model into discreet chunks, without losing control.

More Videos:

SolidWorks Class 101: coffee maker – video 02 of 16 from Adam OHern on Vimeo.

SolidWorks Class 101: coffee maker – video 03 of 16 from Adam OHern on Vimeo.

SolidWorks Class 101: coffee maker – video 04 of 16 from Adam OHern on Vimeo.

This post is a part of an extended video series covering the basics of SolidWorks. If you are new to this series, start here.

Part 2: Building the Parts

• Video 05: other Master Form surfaces
• Video 06: the Handle component
• Video 07: other assembly components
• Video 08: plunger bottom plate
• Video 09: plunger top plate
• Video 10: other plunger parts
• Video 11: the basic lid

In part 2 of our three part SolidWorks class we’ll be implementing the strategy laid out in part 1, and learning lots of tools and techniques along the way. As I progress into the individual part details, I become less and less concerned with using good parametric history technique: the further we get from the “root” of our history tree, the less important it is that we be rigid with our application of best practices, so in the interest of time I’ll be cutting some corners.

This post is a part of an extended video series covering the basics of SolidWorks. If you are new to this series, start here.

Part 3: Details and Export

• Video 12: coil spring
• Video 13: lid details
• Video 14: embossed logo from illustrator
• Video 15: assembly constraints and animation
• Video 16: export to modo, setup basics

Finally, in part 3 of our three part SolidWorks class we’ll look at some trixy techniques for adding the extra little details that really make the model feel complete. The coil spring is a particularly fun tutorial, involving swept surface that twists along a path. We’ll be importing logo graphics from Adobe Illustrator using a DWG drawing, then scaling and locating it using a “block” in the sketcher. Lastly we will take a quick look at some basic assembly constraints, and even create a simple drawing for export to PDF.

As an added bonus, I’ll even fly through the process of setting up a render in modo using our exported SolidWorks geometry. This should be fun!

Shameless call to action:

Buy it now!

My latest video tutorial series is now for sale at luxology.com, and it covers the basic tools and techniques I use to illustrate soft goods; in this case, a backpack.

Most industrial designers use CAD packages to build geometry for “hard goods”, i.e. products that are made of solid materials like plastic, wood, or metal. But designing “soft goods”–products made of fabric, leather, etc–has been primarily a 2D affair until very recently. Modo is a fantastic tool for modeling soft goods, and it’s a part of my daily work flow as a product designer.

After finishing my work with 3DWorld Magazine, Bob over at Luxology asked if I could put together a series breaking down the process of building a backpack concept design in modo.

Now that we’ve seen the basics of Processing, we’ll take a quick look at the simplest-possible “bouncing ball” application. We can get into more complex examples in the future, but for now lets stick to the basics: updating a circle’s location at a constant velocity.

Second video here:

Code:
Note: I recommend typing this out yourself, not copy-paste. The only way to learn a language is to use it, and copy-paste programming won’t get you there.

float xPos;
float yPos;

float xVel;
float yVel;

void setup() {
size(720,400);
smooth();

xPos = width/2;
yPos = height/2;
xVel = 1;
yVel = 2;
}

void draw() {
background(255);

xPos = xPos + xVel;
yPos = yPos + yVel;

if ( yPos + 30 > height || yPos – 30 < 0 ) {
yVel = yVel * -1;
}

if ( xPos + 30 > width || xPos + 30 < 0 ) {
xVel = xVel * -1;
}

fill(0); noStroke();
ellipse(xPos,yPos,60,60);
}

My friend Isaiah is 12 years old, and really wants to learn the basics of programming. Since Java is cross-platform (i.e. it will work on any operating system: Mac, Windows, or Linux), I decided it would be prudent to start with a simple Java framework called “Processing“.

Processing is designed to make visual computing easy to learn. It accommodates very simple syntax and structure, but also allows for “Object-Oriented Programming” (OOP) and the import of external resources called “Libraries” when creating more complex programs.

If you’re thinking about learning to program your Mac or PC, Processing is a great place to start. Here we’ll start at the very beginning. Since every programming language’s foundation is deeply rooted in mathematics, we will not be able to avoid some simple algebra. If you haven’t had algebra yet, don’t worry: the concepts are fairly easy to understand.

If you have questions, be sure to let me know! I’ll try my best to address your questions in subsequent videos.

Keep in touch!

Adam

For the rest of the videos, click here:

Often designers will want to “crown” a complex surface, such as this star shape. This one can be built, but we’ll have to accept that the corners of the star will fade to flat at the ends.

There are several other conceivable solutions to this little problem, but which you use really depends on what you want the surface to look like in the end. I find that when users struggle to build their idea in CAD, it’s usually because the user hasn’t really figured out exactly what he’s trying to make.

I usually recommend getting out a ball of clay and working through it physically at first, just to prove to yourself that the shape is “real”, i.e. it’s a shape that can exist in 3D space. You’d be amazed how often people fool themselves into believing that non-existent shapes can be built in CAD! Once you’ve proven that the shape can exist in clay, then pick up a pencil and start working out your patch layout, keeping in mind that all NURBS surfaces are 4-sided. If you can draw the shape using only 4-sided surfaces, you’re golden. If not, you’re just not looking hard enough!

Keep up the good work, and keep those problems coming!

A fella’ named Lennard was having trouble hardening an interior corner on his model of a Ford alloy rim. Lets take a quick look and see what we could do to fix that.

Creating sewing stitches in Photoshop can be a bit tricky. I’ve got a method involving custom brush tool presets and some fancy actions, and it seems to work well enough for my purposes. What’s your method? Download the brushes, the actions, and watch video #2 after the jump:

Download the brushes and actions here:
SketchboxPresets_100407.zip