With regard to optimization here are a few suggestions, hopefully not to harsh, just trying to help.

• You are currently recalculating the x,y for every vertex in every polygon in every draw() loop. Obviously this is completely inefficient and only suitable for a few shapes. If you have more shapes you should only calculate what is needed ONCE and just store the position in the actual polygon. That is usually what a polygon is, a collection of points (for example pvectors) instead of a 'number of points'. Basically what you are doing in lines 49-54 should be done once in the polygon. Once that is done, the draw() loop wouldn't need to do any calculations for the polygons, just display the points.
• An optional further improvement is to store pre-calculated shapes (3, 4, 5 etc. points) in a LUT, so you'd only have to multiply by rad and add xy at the time of creation. Again, the point is to avoid calculations as much as possible on runtime and doing as little calculations as possible to realise what you want.
  
• So never do the same calculation twice or more (especially if you do that calculation for each polygon, for each vertex). For example in line 23 and 24 you calculate pGet.rot+TWO_PI/pGet.verts*j twice, this is just wasted resources. Do the calculation once, store the result and use it multiple times.
  
• There are a lot of costly calculation in your selection code: sq, sqrt, acos. And again, you are recalculating the position of every vertex in every polygon on each mouseclick, which shouldn't be necessary in the first place if you already have polygons. Once you have actual polygons, you can use this code to check if the mouse is inside the polygon on a mouse click. If it is inside set the selected polygon to this one and break out the loop. I think this is much more optimized and thus suitable for larger amounts of shapes.
• Finally a shorter code remark, you don't need the somethingSelected boolean. You can set the selected variable to -1 if nothing is selected. So your somethingSelected check is: if (selected >= 0)

another thought on optimization:

i found it very helpful to use approximations instead of sin() and cos().
it usually is not that big of a difference, but for your mousePressed function you can increase speed by about 10% if you use following functions:

1. float fastSin(float x){
         float r;
         //always wrap input angle to -PI..PI
         if (x < -3.14159265)
           x += 6.28318531;
         else if (x >  3.14159265)
           x -= 6.28318531;
   
         //compute sine
         if (x < 0){
           r = 1.27323954 * x + .405284735 * x * x;
      
       if (r < 0)
           r = .225 * (r *-r - r) + r;
       else
           r = .225 * (r * r - r) + r;
       }
       else{
         r = 1.27323954 * x - 0.405284735 * x * x;
      
         if (r < 0)
           r = .225 * (r *-r - r) + r;
         else
           r = .225 * (r * r - r) + r;
       }
    
       return r;
   }
      
   float fastCos(float x){
     //compute cosine: sin(x + PI/2) = cos(x)
     float r;
    
     x += 1.57079632;
     if (x >  3.14159265)
       x -= 6.28318531;
   
     if (x < 0)
     {
       r = 1.27323954 * x + 0.405284735 * x * x;
      
       if (r < 0)
           r = .225 * (r *-r - r) + r;
       else
           r = .225 * (r * r - r) + r;
   }
   else
   {
       r = 1.27323954 * x - 0.405284735 * x * x;
   
       if (r < 0)
           r = .225 * (r *-r - r) + r;
       else
           r = .225 * (r * r - r) + r;
   }
   return r;
   }

Amnon.owed, thanks, I implemented a few of those, I'm going to see how to go about storing the vertices once. In the future sketch it is going to be important to draw some polygons at different rotations so I guess I'll just update them when necessary.

Updated version. I'll look into drawing shapes and color testing:

Maybe it helps to have a look at the Google Maps implementation (Java Script):

I have a number of suggestions that should improve the performance of your program.

Is a point inside a convex shape?
A convex shape is one where all the internal angles are <180 degrees and regular polygons meet this requirement.
The algorithm that you are using works but involves a lot of maths, particularly expensive functions like sqrt, acos ... The solution is not to try and make the algorithm faster but find an alternative algorithm. In this case there is a very simple solution to determining "is a point inside a convex shape?"
The new algorithm is

1. pick any point inside the convex shape (in this case we can use the centre position of the polygon) and
   
2. if the line that joins this point with the point we want to test intersects the shapes border then it is not inside the shape. If it does not intersect the border then it is inside the shape
   

 this reduces the problem to testing line intersections which is much easier.

Calculate the polygon vertices once and never change them.
In your program if you want to move or rotate the polygon you have to update the vertex positions. This is very expensive operation and the solution is to use the transformation operations to translate and rotate the drawing matrix.
In the program below when the Polygon constructor remembers the position of the polygon centre (x,y), the polygon rotation (rot) but then calculates vertex coordinates as if the polygon was centerd about the position [0,0] with zero rotation.
The Polygon class has a new method called draw (lines 55 - 70) which is responsible for drawing the polygon at position [x,y] with the rotation rot. Notice that the vertices are not recalculated rather we use the commands translate and rotate to modify the transformation matix instead. We surround these operations with pushMatrx/popMatrix to isolate these transformations from those needed for other polygons.

Is a point inside the polygon?
We are going to use the algorithm described above but we don't want to recalculate the polygon vertices otherwise we lose the benefits gained so far. Lets assume we want to see if the pixel [px, py] lies inside polygon p0 whose centre is [x,y]. When the polygon was created the vertices were calculated on the assumption the centre was [0,0] and when it was drawn this was 'corrected' by changing the transformation matrix. The soltion then is to reverse the polygon transformations and apply them to the point [px,py] so we

1. translate the point relative to the polygon centre (lines 73-74) then
2. rotate the point in the reverse directiorn i.e. -rot (lines 75-78)

The result is a point at  [cpx,cpy]

We now test the line [0,0]-[cpx,cpy] against ALL the lines that make up the polygon border (lines 79-84) and if there is an intersection the point is outside the polygon.

Other changes made
Since we have a convex shape I can use the TRIANGLE_FAN when drawing the polygon.
The Polygon objects are responsible for drawing themselves and determining whether a point is inside its boudary, this simplifies the use of the polygon objects in the main program (In object orientation classes should be responsible for managing their own attributes/variables/state).

The following sketch has 2 rotating polygons which change colour when the cursor is inside the polygon.

HTH

1. Polygon p0, p1;
2. int colorIn, colorOut;
3. float rotAngle;
4. 
   
5. void setup() {
6.   size(400, 400);
7.   cursor(CROSS);
8.   colorOut = color(100, 200, 100);
9.   colorIn = color(200, 100, 100);
10.   p0 = new Polygon(50, 110, 90, 5, 0.1f);
11.   p1 = new Polygon(120, 250, 280, 7, 0.5f);
12. }
13. 
    
14. void draw() {
15.   background(255);
16.   pushMatrix();
17.   p0.changeRotAngle(0.03f);
18.   p1.changeRotAngle(0.05f);
19.   if (p0.isInside(mouseX, mouseY))
20.     p0.draw(this, colorIn);
21.   else
22.     p0.draw(this, colorOut);
23.   if (p1.isInside(mouseX, mouseY))
24.     p1.draw(this, colorIn);
25.   else
26.     p1.draw(this, colorOut);
27.   p1.draw(this, color(100, 255, 100, 32));
28.   popMatrix();
29. }
30. 
    
31. public class Polygon {
32.   float rad, rot, x, y;
33.   int verts;
34.   float[] vx, vy;
35. 
    
36.   Polygon(float inRad, float inX, float inY, int inVe, float inRo) {
37.     rad = inRad;
38.     rot = inRo;
39.     x = inX;
40.     y = inY;
41.     verts = inVe;
42.     vx = new float[verts];
43.     vy = new float[verts];
44.     float deltaAngle = TWO_PI/verts;
45.     for (int i = 0; i < verts; i++) {
46.       vx[i] = rad * cos(deltaAngle * i);
47.       vy[i] = rad * sin(deltaAngle * i);
48.     }
49.   }
50. 
    
51.   public void changeRotAngle(float deltaAngle) {
52.     rot += deltaAngle;
53.   }
54. 
    
55.   public void draw(PApplet app, int fillCol) {
56.     app.pushStyle();
57.     app.pushMatrix();
58.     app.translate(x, y);
59.     app.rotate(rot);   
60.     app.fill(fillCol);
61.     app.noStroke();       
62.     app.beginShape(TRIANGLE_FAN);
63.     app.vertex(0, 0);
64.     for (int i = 0; i < verts; i++)
65.       app.vertex(vx[i], vy[i]);
66.     app.vertex(vx[0], vy[0]);
67.     app.endShape();
68.     app.popMatrix();
69.     app.popStyle();
70.   }
71. 
    
72.   public boolean isInside(float px, float py) {
73.     px -= x;
74.     py -= y;
75.     float sinA = sin(-rot);
76.     float cosA = cos(-rot);
77.     float cpx = px * cosA - py * sinA;
78.     float cpy = px * sinA + py * cosA;
79.     for (int i = 0; i < verts -1; i++) {
80.       if (linesIntersect(cpx, cpy, 0, 0, vx[i], vy[i], vx[i+1], vy[i+1]))
81.         return false;
82.     }
83.     if (linesIntersect(cpx, cpy, 0, 0, vx[verts-1], vy[verts-1], vx[0], vy[0]))
84.       return false;
85.     return true;
86.   }
87. 
    
88.   // See if the lines ab and cd intersect
89.   private boolean linesIntersect(float aX, float aY, float bX, float bY,
90.                                  float cX, float cY, float dX, float dY)  {
91.     float rTop = (aY-cY)*(dX-cX)-(aX-cX)*(dY-cY);
92.     float sTop = (aY-cY)*(bX-aX)-(aX-cX)*(bY-aY);
93.     float bot = (bX-aX)*(dY-cY)-(bY-aY)*(dX-cX);
94.     if (bot == 0) // parallel therefor do noy intersect
95.       return false;
96.     float invBot = 1.0f/bot;
97.     float r = rTop * invBot;
98.     float s = sTop * invBot;
99.     if ( (r > 0) && (r < 1) && (s > 0) && (s < 1) )
100.       return true;
101.     return false;
102.   }
103. }

Thank you :)

Have you tried using PShape? It does everything you're trying to do and more although I dont know how fast the PShape.contains() method is...

PShape, at least in 1.5.1 (I think the limitation is lifted in 2.0) cannot be used directly to create a new shape.
By extending it and filling the vertices, vertexCount and other fields, you can create a PShape, but that's some additional work.

Right, I've been using 2.0 so I havent had the 1.5 private vertex data variables/methods problem for a while but doing it in 2.0 is fast and easy.