make decisions about the type of "code" to show #3

ofZach · 2015-11-14T17:51:05Z

ie, do we use c++? OF? pseudo code?

this is for the text template that people will see with the visuals...

ofZach · 2015-11-14T18:30:57Z

It generally feels like psuedo code would be good -- we should come up with guidelines for what this looks like....

ofZach · 2015-11-14T23:11:05Z

maybe: no curly brackets, no "of" specificiers, no opengl specific stuff, no variable types, etc:

for ( i = 0; i < 10; i++){
     rect ( i, i, 10, 10);
}

mayakraft · 2015-11-16T00:01:20Z

wondering about how many lines of code to include, I'm thinking about only including what gives the piece character.

for instance my vera molnar scene is a 6x6 grid of the jumbly squares. it's clear to the viewer that there are 36 copies of a thing. i can leave out that code that says "make 36 copies, arrange them x y 6x6", then i can focus on what makes just one of the squares.

thinking about bridget riley, however, her pieces are all about copies, with small changes each time, so it makes sense to have the loop that makes copies of a thing.

mayakraft · 2015-11-16T00:27:47Z

I've gone down a rabbit hole, not sure how productive this is, here's a couple iterations of code turning into pseudo-code.

Do any of these sound like good ideas / just too much work?

no changes

void veraRect::drawPerturbedRect(float x, float y, float width, float height,
                                 float X_PERTURB_TL, float Y_PERTURB_TL,
                                 float X_PERTURB_TR, float Y_PERTURB_TR,
                                 float X_PERTURB_BR, float Y_PERTURB_BR,
                                 float X_PERTURB_BL, float Y_PERTURB_BL){

    float topLeftX = (x + (width*X_PERTURB_TL) - (width*X_PERTURB_TL*.5));
    float topLeftY = (y + (height*Y_PERTURB_TL) - (height*Y_PERTURB_TL*.5));
    float topRightX = (x + width + (width*X_PERTURB_TR) - (width*X_PERTURB_TR*.5));
    float topRightY = (y + (height*Y_PERTURB_TR) - (height*Y_PERTURB_TR*.5));
    float bottomRightX = (x + width + (width*X_PERTURB_BR) - (width*X_PERTURB_BR*.5));
    float bottomRightY = (y + height + (height*Y_PERTURB_BR) - (height*Y_PERTURB_BR*.5));
    float bottomLeftX = (x + (width*X_PERTURB_BL) - (width*X_PERTURB_BL*.5));
    float bottomLeftY = (y + height + (height*Y_PERTURB_BL) - (height*Y_PERTURB_BL*.5));

    ofDrawLine(topLeftX, topLeftY, topRightX, topRightY);
    ofDrawLine(topRightX, topRightY, bottomRightX, bottomRightY);
    ofDrawLine(bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
    ofDrawLine(bottomLeftX, bottomLeftY, topLeftX, topLeftY);
}

void veraRect::draw(int numRects, float d){
    for(int i = 0; i < numRects; i++){
        drawPerturbedRect(centerX - radius[i]*.5, centerY - radius[i]*.5, radius[i], radius[i],
                          d*(perturb[i*8+0] + an[i*8+0]*sinf(an[i*8+1]*ofGetElapsedTimef())), d*(perturb[i*8+1] + an[i*8+0]*cosf(an[i*8+1]*ofGetElapsedTimef())),
                          d*(perturb[i*8+2] + an[i*8+2]*sinf(an[i*8+3]*ofGetElapsedTimef())), d*(perturb[i*8+3] + an[i*8+2]*cosf(an[i*8+3]*ofGetElapsedTimef())),
                          d*(perturb[i*8+4] + an[i*8+4]*sinf(an[i*8+5]*ofGetElapsedTimef())), d*(perturb[i*8+5] + an[i*8+4]*cosf(an[i*8+5]*ofGetElapsedTimef())),
                          d*(perturb[i*8+6] + an[i*8+6]*sinf(an[i*8+7]*ofGetElapsedTimef())), d*(perturb[i*8+7] + an[i*8+6]*cosf(an[i*8+7]*ofGetElapsedTimef())));
    }
}

changes 1

make openframeworks calls generic, ofdrawline() = line()
get rid of types
get rid of c++ class notation, double colon stuff
make sinf() into sin()

drawPerturbedRect(x, y, width, height, X_PERTURB_TL, Y_PERTURB_TL, 
                                       X_PERTURB_TR, Y_PERTURB_TR, 
                                       X_PERTURB_BR, Y_PERTURB_BR, 
                                       X_PERTURB_BL, Y_PERTURB_BL){

    topLeftX = (x + (width*X_PERTURB_TL) - (width*X_PERTURB_TL*.5));
    topLeftY = (y + (height*Y_PERTURB_TL) - (height*Y_PERTURB_TL*.5));
    topRightX = (x + width + (width*X_PERTURB_TR) - (width*X_PERTURB_TR*.5));
    topRightY = (y + (height*Y_PERTURB_TR) - (height*Y_PERTURB_TR*.5));
    bottomRightX = (x + width + (width*X_PERTURB_BR) - (width*X_PERTURB_BR*.5));
    bottomRightY = (y + height + (height*Y_PERTURB_BR) - (height*Y_PERTURB_BR*.5));
    bottomLeftX = (x + (width*X_PERTURB_BL) - (width*X_PERTURB_BL*.5));
    bottomLeftY = (y + height + (height*Y_PERTURB_BL) - (height*Y_PERTURB_BL*.5));

    line(topLeftX, topLeftY, topRightX, topRightY);
    line(topRightX, topRightY, bottomRightX, bottomRightY);
    line(bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
    line(bottomLeftX, bottomLeftY, topLeftX, topLeftY);
}

draw(numRects, d){
    for(i = 0; i < numRects; i++){
        drawPerturbedRect(centerX - radius[i]*.5, centerY - radius[i]*.5, radius[i], radius[i],
                          d*(perturb[i*8+0] + an[i*8+0]*sinf(an[i*8+1]*time())), 
                          d*(perturb[i*8+1] + an[i*8+0]*cosf(an[i*8+1]*time())),
                          d*(perturb[i*8+2] + an[i*8+2]*sinf(an[i*8+3]*time())), 
                          d*(perturb[i*8+3] + an[i*8+2]*cosf(an[i*8+3]*time())),
                          d*(perturb[i*8+4] + an[i*8+4]*sinf(an[i*8+5]*time())), 
                          d*(perturb[i*8+5] + an[i*8+4]*cosf(an[i*8+5]*time())),
                          d*(perturb[i*8+6] + an[i*8+6]*sinf(an[i*8+7]*time())), 
                          d*(perturb[i*8+7] + an[i*8+6]*cosf(an[i*8+7]*time())));
    }
}

changes 2

made spacing the same
changed variable names to more like English

draw(numberOfRectangles, disarray){
    for(i = 0; i < numberOfRectangles; i++){
        drawPerturbedRect(centerX - radius[i]*.5, centerY - radius[i]*.5, 
                          radius[i], radius[i],
                          disarray * ( wobble[i*8+0] + magnitude[i*8+0] * sin(magnitude[i*8+1] * time() ) ), 
                          disarray * ( wobble[i*8+1] + magnitude[i*8+0] * cos(magnitude[i*8+1] * time() ) ),
                          disarray * ( wobble[i*8+2] + magnitude[i*8+2] * sin(magnitude[i*8+3] * time() ) ), 
                          disarray * ( wobble[i*8+3] + magnitude[i*8+2] * cos(magnitude[i*8+3] * time() ) ),
                          disarray * ( wobble[i*8+4] + magnitude[i*8+4] * sin(magnitude[i*8+5] * time() ) ), 
                          disarray * ( wobble[i*8+5] + magnitude[i*8+4] * cos(magnitude[i*8+5] * time() ) ),
                          disarray * ( wobble[i*8+6] + magnitude[i*8+6] * sin(magnitude[i*8+7] * time() ) ), 
                          disarray * ( wobble[i*8+7] + magnitude[i*8+6] * cos(magnitude[i*8+7] * time() ) ) );
    }
}

drawPerturbedRect(x, y, width, height, X_PERTURB_TL, Y_PERTURB_TL, 
                                       X_PERTURB_TR, Y_PERTURB_TR, 
                                       X_PERTURB_BR, Y_PERTURB_BR, 
                                       X_PERTURB_BL, Y_PERTURB_BL){

    topLeftX =     (x + (width  * X_PERTURB_TL)         - (width  * X_PERTURB_TL * .5));
    topLeftY =     (y + (height * Y_PERTURB_TL)         - (height * Y_PERTURB_TL * .5));
    topRightX =    (x + width   + (width*X_PERTURB_TR)  - (width  * X_PERTURB_TR * .5));
    topRightY =    (y + (height * Y_PERTURB_TR)         - (height * Y_PERTURB_TR * .5));
    bottomRightX = (x + width   + (width*X_PERTURB_BR)  - (width  * X_PERTURB_BR * .5));
    bottomRightY = (y + height  + (height*Y_PERTURB_BR) - (height * Y_PERTURB_BR * .5));
    bottomLeftX =  (x + (width  * X_PERTURB_BL)         - (width  * X_PERTURB_BL * .5));
    bottomLeftY =  (y + height  + (height*Y_PERTURB_BL) - (height * Y_PERTURB_BL * .5));

    line(topLeftX, topLeftY, topRightX, topRightY);
    line(topRightX, topRightY, bottomRightX, bottomRightY);
    line(bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
    line(bottomLeftX, bottomLeftY, topLeftX, topLeftY);
}

changes 3

make changes that break the code, but get the point across, like this:

drawPerturbedRect(x, y, width, height, X_PERTURB_TL, Y_PERTURB_TL, 
                                       X_PERTURB_TR, Y_PERTURB_TR, 
                                       X_PERTURB_BR, Y_PERTURB_BR, 
                                       X_PERTURB_BL, Y_PERTURB_BL){

becomes: drawPerturbedRect(x, y, width, height, perturb){

draw(numberOfRectangles, disarray){
    for(i = 0; i < numberOfRectangles; i++){
        drawPerturbedRect(centerX - radius[i]*.5, centerY - radius[i]*.5, 
                          radius[i], radius[i],
                          disarray * ( wobble[i*8+0] + magnitude[i*8+0] * sin(magnitude[i*8+1] * time() ) ), 
                          disarray * ( wobble[i*8+1] + magnitude[i*8+0] * cos(magnitude[i*8+1] * time() ) ),
                          disarray * ( wobble[i*8+2] + magnitude[i*8+2] * sin(magnitude[i*8+3] * time() ) ), 
                          disarray * ( wobble[i*8+3] + magnitude[i*8+2] * cos(magnitude[i*8+3] * time() ) ),
                          disarray * ( wobble[i*8+4] + magnitude[i*8+4] * sin(magnitude[i*8+5] * time() ) ), 
                          disarray * ( wobble[i*8+5] + magnitude[i*8+4] * cos(magnitude[i*8+5] * time() ) ),
                          disarray * ( wobble[i*8+6] + magnitude[i*8+6] * sin(magnitude[i*8+7] * time() ) ), 
                          disarray * ( wobble[i*8+7] + magnitude[i*8+6] * cos(magnitude[i*8+7] * time() ) ) );
    }
}

drawPerturbedRect(x, y, width, height, perturb){

    topLeftX =     (x + perturb.TopLeft              );
    topLeftY =     (y + perturb.TopLeft              );
    topRightX =    (x + perturb.TopRight    + width  );
    topRightY =    (y + perturb.TopRight             );
    bottomRightX = (x + perturb.BottomRight + width  );
    bottomRightY = (y + perturb.BottomRight + height );
    bottomLeftX =  (x + perturb.BottomLeft           );
    bottomLeftY =  (y + perturb.BottomLeft  + height );

    line(topLeftX, topLeftY, topRightX, topRightY);
    line(topRightX, topRightY, bottomRightX, bottomRightY);
    line(bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
    line(bottomLeftX, bottomLeftY, topLeftX, topLeftY);
}

andyinabox · 2015-11-16T04:29:06Z

Nice! Do we want to include comments too? Seems like that could go a long way toward making it clear what's going on...

ofZach · 2015-11-16T16:49:56Z

it feels like it's getting closer ! I agree that comments would help... it feels like if it can fit in one or two functions like this it's good.

mayakraft · 2015-11-24T05:53:50Z

more compression:

whenever this is a line that looks like it's copied 8 times, replace it with one. (stride)
break the code if necessary (yes/no?)
Andy's suggestion: add comments

draw(numberOfRectangles, disarray){
// wobble and magnitude used in trig functions to slightly affect the position of the corners (disarray)
    for(i = 0; i < numberOfRectangles; i++){
        drawPerturbedRect(centerX - radius[i]*.5, centerY - radius[i]*.5, 
                          radius[i], radius[i],
                          disarray * ( wobble[i*8] + magnitude[i*8] * sin(magnitude[i*8] * time() ) ) );

    }
}

drawPerturbedRect(x, y, width, height, perturb){
// "perturb" contains values to offset each corner of the square,
// making it irregular, but consistent between each frame
    topLeftX =     (x + perturb.TopLeft              );
    topLeftY =     (y + perturb.TopLeft              );
    topRightX =    (x + perturb.TopRight    + width  );
    topRightY =    (y + perturb.TopRight             );
    bottomRightX = (x + perturb.BottomRight + width  );
    bottomRightY = (y + perturb.BottomRight + height );
    bottomLeftX =  (x + perturb.BottomLeft           );
    bottomLeftY =  (y + perturb.BottomLeft  + height );

    line(topLeftX, topLeftY, topRightX, topRightY);
    line(topRightX, topRightY, bottomRightX, bottomRightY);
    line(bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
    line(bottomLeftX, bottomLeftY, topLeftX, topLeftY);
}

ofZach · 2015-11-24T07:43:22Z

Looking good! Anything you can do to feature your params is also good. Code can break for sure no one will be trying this code out :) it's more showing the idea

ofZach · 2015-12-10T23:44:08Z

I wonder if here, we could even just drop the drawPerturbedRect part of the code and just focus on the draw call....

ofZach · 2015-12-10T23:44:54Z

ie: more like this:

// wobble and magnitude used in trig functions to slightly affect the position of the corners (disarray)
    for(i = 0; i < numberOfRectangles; i++){
        drawPerturbedRect(centerX - radius[i]*.5, centerY - radius[i]*.5, 
                          radius[i], radius[i],
                          disarray * ( wobble[i*8] + magnitude[i*8] * sin(magnitude[i*8] * time() ) ) );

    }

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

make decisions about the type of "code" to show #3

make decisions about the type of "code" to show #3

ofZach commented Nov 14, 2015

ofZach commented Nov 14, 2015

ofZach commented Nov 14, 2015

mayakraft commented Nov 16, 2015

mayakraft commented Nov 16, 2015

andyinabox commented Nov 16, 2015

ofZach commented Nov 16, 2015

mayakraft commented Nov 24, 2015

ofZach commented Nov 24, 2015

ofZach commented Dec 10, 2015

ofZach commented Dec 10, 2015

make decisions about the type of "code" to show #3

make decisions about the type of "code" to show #3

Comments

ofZach commented Nov 14, 2015

ofZach commented Nov 14, 2015

ofZach commented Nov 14, 2015

mayakraft commented Nov 16, 2015

mayakraft commented Nov 16, 2015

no changes

changes 1

changes 2

changes 3

andyinabox commented Nov 16, 2015

ofZach commented Nov 16, 2015

mayakraft commented Nov 24, 2015

ofZach commented Nov 24, 2015

ofZach commented Dec 10, 2015

ofZach commented Dec 10, 2015