// Angs used in rotate function calls above
  for (int i = 0; i < cubeCount; i++){
    angs[i] += rotvals[i];
  }

This is adding to the values in the angs[] array, which determines the angle of rotation for each cube.  You can replace the contents of this loop to produce the effect you are looking for.  The problem is, all you have is i, which is the cube number, and you need to find a way to convert that to the screen position of the cube, so you can compare it to the mouse position.

The double loop above which draws the cubes looks like this:

 for (int i = 0; i < cols; i++) {

 for (int j = 0; j < rows; j++){ 

This means the X coordinate of the cube is i * colSpan  and the Y coordinate of the cube is j * colSpan.

The (* colSpan) gets us from "grid coordinates" to pixel coordinates.

So in our original loop, we can convert i to x/y pixel positions using

      float y = (i % cols)*rowSpan;
      float x = ((int) i/cols)*colSpan;
               

                

               
               

                This is magic formula I use a lot to get from a counter to pixel coordinates.  It's the inversion of:
               
               

                

               
               

                     i = (x/colSpan)*cols+(y/rowSpan);
               
               

                

               
               

                Which shows how to derive a counter in a double loop (assuming x is the outer loop).
               
               

                

               
               

                Distance from the mouse is computed as follows:
               
               

                

               
               

                

                       float dx = mouseX-x;
                
                

                       float dy = mouseY-y;
                
                

                       float distance = sqrt(sq(dx)+sq(dy));
                
                

                 

                
                

                       or more simply:
                
                

                 

                
                

                       float distance = dist(x,y,mouseX,mouseY); 
                
                

                 

                
               
               

                I can convert this distance to a rotation value using map() and constrain(), like so (tweak the numbers to your taste,
               
               

                100 is the distance of the furthest affected cube, and 40 is the amount of the fastest rotation
               
               

                

               
               

                

                       float rotVal = map(100-distance,240,0,40,0);
                
                

                       rotVal = constrain(rotVal, 0, 40);
                
                

                 

                
                

                 The first line maps the distance to a value that goes from 40 to 0 over the radius of the circle of influence.  The second line prevents it from dropping below zero outside the circle of influence.
                
                

                 

                
                

                 To cause the cubes to rotate back to zero, I added a damping equation, which is kind of cool...
                
                

                 

                
                

                  angs[i] *= .95;
                
                

                 

                
                

                 So we get:
                
               
               

                

               
               

                

                 
for (int i = 0; i < cubeCount; i++){ 
                 
  if (pmouseX != mouseX || pmouseY != mouseY) { 
                 
    float y = (i % cols)*rowSpan; 
                 
    float x = ((int) i/cols)*colSpan; 
                 
    float distance = dist(x,y,mouseX,mouseY); 
                 
    float rotVal = map(240-distance,240,0,60,0); 
                 
    rotVal = constrain(rotVal, 0, 60); 
                 
    angs[i] += rotVal; 
                 
  } 
                 
  angs[i] *= .9;  // added damping so rotation falls back to zero
                 
}
                
               
               

                Again, in my opinion, this is very advanced stuff for a newb.  :)