You're looping through the code in draw() 400 times every frame, but that should still be possible...

I've been running it for a couple of minutes now, and the frame rate hasn't dropped from 60.
It's probably your hardware...

I have Windows 7 64 bit.

Pretty nice result, too.

Perhaps avoid the println(), as it fills the console...

I removed the print and it didn't help frame rate all that much. Im pretty sure the problem is my hardware, windows 7 32 bit and I have  2 gigs of ram with 2.1GHz processor but im noticing these kind of issues with other programs. perhaps its time to up my Ram or clean up my hard drive?

Thanks guys!

1. float culr;
   float moveZ;
2. int sizeIn_Pix=8;
   int sizeMargin_Pix=1;
   //
   int groupSize=2;
   int gridsizeX=100;
   int gridsizeY=100;
   //
   int sizeOut_Pix=sizeIn_Pix+sizeMargin_Pix;
   int groupSize_Pix=groupSize*sizeOut_Pix;
3. void setup() {
     size(gridsizeX*sizeOut_Pix, gridsizeY*sizeOut_Pix);
     background(0);
     colorMode(HSB);
   }
   void draw() {
     for (int x = 0; x < width; x = x + sizeOut_Pix) {
       for (int y = 0; y < height; y = y + sizeOut_Pix) {
         culr = noise(x/groupSize_Pix, y/groupSize_Pix, moveZ)*150;
         fill(culr, 360, 360);
         rect(x, y, sizeIn_Pix, sizeIn_Pix);
       }
     }
     moveZ+=0.01;
   }//draw()
   

 

1. float culr;
   float moveZ;
2. int sizeIn_Pix=6;
   int sizeMargin_Pix=1;
   //
   int groupSize=2;
   int nGroupX=80;
   int nGroupY=80;
   int wiggle=16; //0 for no wiggle
   int buggle=16; //0 for no buggle
   //
   int sizeOut_Pix=sizeIn_Pix+sizeMargin_Pix;
   int groupSize_Pix=groupSize*sizeOut_Pix;
   int wiggles=2*wiggle+1;
   int buggles=2*buggle+1;
3. 
   void setup() {
     size(groupSize*nGroupX*sizeOut_Pix, groupSize*nGroupY*sizeOut_Pix);
     background(0);
     colorMode(HSB);
   }
   void draw() {
     for (int x = 0; x < width; x = x + sizeOut_Pix) {
       for (int y = 0; y < height; y = y + sizeOut_Pix) {
         culr = noise(x/groupSize_Pix, y/groupSize_Pix, moveZ)*150;
         fill(culr, 360, 360);
         float xx=x+floor(random(wiggles)-wiggle);
         float yy=y+floor(random(wiggles)-wiggle);
         float sxx=sizeIn_Pix+floor(random(buggles)-buggle);
         float syy=sizeIn_Pix+floor(random(buggles)-buggle);
         rect(xx, yy, sxx, syy);
       }
     }
     moveZ+=0.01;
   }//draw()
   

Hey nice work eltodesukane!  The first one is awesome, i think maybe if you took out the borders of the rectangles with noStroke() it might look even better.

The reason why the color of a 4x4 grid is the same is I think because processing rounds of the values to the nearest integer when dividing, so because of that the 16 blocks in the 4x4 grid happen to have the same 'culr'/noise values  same because their "x/(100)" values are rounded to the same integer. Try it out with values other than 100, you will notice that because there are 500 pixels in the width, using a simple calculation 500/100 = 5, we find that the answer is the number groups of color each row.

try it out with x/200 and y/200, you will find that every row has 2.5 groups with the same color, the value basically determines after how many pixels the color will change

I hope this helps! : )

and check this out: http://www.openprocessing.org/sketch/59248
The additions were inspired by your question :)

Hey nice work eltodesukane!  The first one is awesome, i think maybe if you took out the borders of the rectangles with noStroke() it might look even better.

The reason why the color of a 4x4 grid is the same is I think because processing rounds of the values to the nearest integer when dividing, so because of that the 16 blocks in the 4x4 grid happen to have the same 'culr'/noise values  same because their "x/(100)" values are rounded to the same integer. Try it out with values other than 100, you will notice that because there are 500 pixels in the width, using a simple calculation 500/100 = 5, we find that the answer is the number groups of color each row.

try it out with x/200 and y/200, you will find that every row has 2.5 groups with the same color, the value basically determines after how many pixels the color will change

I hope this helps! : )

and check this out: http://www.openprocessing.org/sketch/59248
The additions were inspired by your question :)

I have another question, (i dnt knw if this qualifies to be new topic so ill add it here first) I added a couple of more features to my sketch and one of them involves divison by an integer 1 and a float 1.0 to get the effect of a continuous and discontinuous color for my rects in the sketch.

Here's the improved code:

1. float culr;
2. float moveZ;
3. int fix =100;
4. int factor =1;
5. boolean state = true;
6. int counter;
7. void setup() {
8.   size(500, 500);
9.   background(0);
10.   colorMode(HSB);
11.   frameRate(60);
12. }
13. void draw() {
14.  
15.   background(0);
16.   if (state == true) { //Alternates b/w continuos and discontinuous patterns based on the state
17.     for (int x = 0; x < width; x = x + 25) {
18.       for (int y = 0; y < height; y = y + 25) {
19.         culr = noise(x/(1*fix*factor), y/(1 *fix*factor), moveZ)*360; // note the "1", multiplying by all 'ints' keeps the value of (1 *fix*factor) an int,
20.         // thus producting discontinuos pattern of colors                                   
21.         fill(culr, 360, 360);
22.         roundedRect(x+2.5, y+2.5, 20, 20, 10, 10);
23.       }
24.     }
25.   }
26.   else {
27.     for (int x = 0; x < width; x = x + 25) {
28.       for (int y = 0; y < height; y = y + 25) {
29.         culr = noise(x/(1.0*fix*factor), y/(1.0*fix*factor), moveZ)*360; // note the "1.0", multiplying by a float makes the value of (1*fix*factor) a float,
30.         // thus producting a continuos pattern of colors                                   
31.         fill(culr, 360, 360);
32.         roundedRect(x+2.5, y+2.5, 20, 20, 10, 10);
33.       }
34.     }
35.   }
36.   moveZ+=0.01; // increments the Z input of noise so that the pattern changes
37. }
38. void roundedRect(float x, float y, float w, float h, float rx, float ry) { //Code adapted from "cefnhoile", heres the link: https://forum.processing.org/topic/rounded-rectangle .
39.   noStroke();
40.   smooth();
41.   beginShape();
42.   vertex(x, y+ry); //top of left side
43.   bezierVertex(x, y, x, y, x+rx, y); //top left corner
44.   vertex(x+w-rx, y); //right of top side
45.   bezierVertex(x+w, y, x+w, y, x+w, y+ry); //top right corner
46.   vertex(x+w, y+h-ry); //bottom of right side
47.   bezierVertex(x+w, y+h, x+w, y+h, x+w-rx, y+h); //bottom right corner
48.   vertex(x+rx, y+h); //left of bottom side
49.   bezierVertex(x, y+h, x, y+h, x, y+h-ry); //bottom left corner
50.   endShape(CLOSE);
51. }
52. void mousePressed() { // changes the 'factor' and 'fix' vars using the bottom right rect ,
53.   // bottom left rect, and rects of those two as buttons
54.   if (mousePressed && mouseX>=480 && mouseY>=460 && mouseY<480) { // rect above bottom right
55.     fix *=10;
56.   }
57.   if (mousePressed && mouseX>=480 && mouseY>=480 && fix !=1) { //bottom right
58.     fix /=10;
59.   }
60.   if (mousePressed && mouseX<=20 && mouseY>=460 && mouseY<480) { // rect above bottom left
61.     factor +=1;
62.   }
63.   if (mousePressed && mouseX<=20 && mouseY>=480 && factor !=1) { //bottom left
64.     factor -=1;
65.   }
66. }
67. void keyPressed() {
68.   if (key == ' ') {
69.     counter++;
70.   }
71.   if (counter%2 ==0) { //everytime the spacebar is pressed the states
72.     //alternate b/w continuous and "blocky" color
73.     state = true;
74.   }
75.   else {
76.     state = false;
77.   }
78. }

How about using something such as the following in place of either 1 or 1.0:

1. (state ? 1 : 1.0)

Great Ill check that out!
Ill implement it and update you
 thanks a mil calsign

I put this: (((state == true) ? 1.0 : 1 )  instead of 1 or 1.0 and it didnt work, I tried different things and printed the results and heres what I got:

expression1 : expression2   --->   My Result when state true
1.0 : 1 ------->  1.0
1 : 1.0 ------->  1.0
1 : 1 ------->  1

Is this an implementation issue or something with the function itself?

I don't see how dividing by 1 or 1.0 can make any difference! Dividing by a bigger number makes a difference, depending if the divided number is integer or not, but by 1, you still get identity.
I am not sure to understand what you are trying to achieve.

I wish I could explain how that makes a difference, from my limited knowledge it has something to do with making the answer an int or float depending on what you divide by.

just try this code out and press the Space and just see what happens:

1. /*
2.  * Murtaza Tunio - 2012
3.  * Candy_exp
4.  *
5.  *Press Spacebar to change b/w continuous and discontinuous coloring of blocks
6.  *The bottom right,the bottom left rect, and the respective rects above them
7.  *to change various variables
8.  *
9.  */
10. float culr;
11. float moveZ;
12. int fix =100;
13. int factor =1;
14. boolean state = true;
15. int counter;
16. void setup() {
17.   size(500, 500);
18.   background(0);
19.   colorMode(HSB);
20.   frameRate(60);
21. }
22. void draw() {
23.   background(0);
24.   if (state == true) { //Alternates b/w continuos and discontinuous patterns based on the state
25.     for (int x = 0; x < width; x = x + 25) {
26.       for (int y = 0; y < height; y = y + 25) {
27.         culr = noise(x/(1*fix*factor), y/(1 *fix*factor), moveZ)*360; // note the "1", multiplying by all 'ints' keeps the value of (1 *fix*factor) an int,
28.         // thus producting discontinuos pattern of colors                                  
29.         fill(culr, 360, 360);
30.         roundedRect(x+2.5, y+2.5, 20, 20, 10, 10);
31.       }
32.     }
33.   }
34.   else {
35.     for (int x = 0; x < width; x = x + 25) {
36.       for (int y = 0; y < height; y = y + 25) {
37.         culr = noise(x/(1.0*fix*factor), y/(1.0*fix*factor), moveZ)*360; // note the "1.0", multiplying by a float makes the value of (1*fix*factor) a float,
38.         // thus producting a continuos pattern of colors                                  
39.         fill(culr, 360, 360);
40.         roundedRect(x+2.5, y+2.5, 20, 20, 10, 10);
41.       }
42.     }
43.   }
44.   moveZ+=0.01; // increments the Z input of noise so that the pattern changes
45. }
46. void roundedRect(float x, float y, float w, float h, float rx, float ry) { //Code adapted from "cefnhoile", heres the link: https://forum.processing.org/topic/rounded-rectangle .
47.   noStroke();
48.   smooth();
49.   beginShape();
50.   vertex(x, y+ry); //top of left side
51.   bezierVertex(x, y, x, y, x+rx, y); //top left corner
52.   vertex(x+w-rx, y); //right of top side
53.   bezierVertex(x+w, y, x+w, y, x+w, y+ry); //top right corner
54.   vertex(x+w, y+h-ry); //bottom of right side
55.   bezierVertex(x+w, y+h, x+w, y+h, x+w-rx, y+h); //bottom right corner
56.   vertex(x+rx, y+h); //left of bottom side
57.   bezierVertex(x, y+h, x, y+h, x, y+h-ry); //bottom left corner
58.   endShape(CLOSE);
59. }
60. void mousePressed() { // changes the 'factor' and 'fix' vars using the bottom right rect ,
61.   // bottom left rect, and rects of those two as buttons
62.   if (mousePressed && mouseX>=480 && mouseY>=460 && mouseY<480) { // rect above bottom right
63.     fix *=10;
64.   }
65.   if (mousePressed && mouseX>=480 && mouseY>=480 && fix !=1) { //bottom right
66.     fix /=10;
67.   }
68.   if (mousePressed && mouseX<=20 && mouseY>=460 && mouseY<480) { // rect above bottom left
69.     factor +=1;
70.   }
71.   if (mousePressed && mouseX<=20 && mouseY>=480 && factor !=1) { //bottom left
72.     factor -=1;
73.   }
74. }
75. void keyPressed() {
76.   if (key == ' ') {
77.     counter++;
78.   }
79.   if (counter%2 ==0) { //everytime the spacebar is pressed the states
80.     //alternate b/w continuous and "blocky" color
81.     state = true;
82.   }
83.   else {
84.     state = false;
85.   }
86. }

 Yes you still get identity but changes what its divided by (a float or int) and that somehow effects whether the result is a rounded int or a float

" note the "1.0", multiplying by a float makes the value of (1*fix*factor) a float,"
Well, you can get the same effect with (float) value, or, in Processing only, by float(value).
Likewise, we have (int) value and int(value).
And if either fix or factor is a float, the result of the multiplication will be a float anyway.