• The last sketches

  15 November 2017

  Yesterday a few of us gathered at SFPC for one last collaborative sketch with Zach. We made some sketches to be used with the recoded framework. We worked with image assets from Zipeng Zhu, which has some really fun food vector art on instagram. The results came out well. I made a type-based sushi conveyer belt.

• Showcase time!

  12 November 2017

  

  … And the showcase is finally here! Proud to be part of the show, and proud that I finally made the project that had been in my mind for so long.

  

  At some point I will do a writeup of the Entangled Chimes project, as I had a lot of good learnings from it and want to share it with more people.

• Final week mode

  05 November 2017

  With most of the classes ramping down and the final week in progress, it’s finally time to get working on the final project. For my final project, I wanted to work on a physical installation, as it is something I am less familiar with, and really wanted to use this as a learning opportunity.

  

  SFPC is becoming a lot more focused, with less events and chatter, and more late nights. Taeyoon was really nice to come in to make dinner for us while we were hard at work.

  

• Some curious observations on OpenFrameworks

  30 October 2017

  OpenFrameworks can be challenging to someone not coming from a C++ background. It can also be challenging if you’re unfamiliar with the quirks which make OF different from Processing.

  Here are some that I ran into that might help:

  One technique to make the shapes you draw fade out is to draw a rectangle with opacity over it. But OpenFrameworks always clears the background at each draw cycle. To stop it from doing that, do:

  void ofApp::setup() {
    ofSetBackgroundAuto(false);
  }
  
  void ofApp::draw() {
    ofSetColor(0, 200); // set color with opacity
    ofDrawRectangle(0, 0, ofGetWidth(), ofGetHeight()); // draw over full screen
  }

  Sometimes openframeworks doesnt draw in the first couple of frames, and you might do some calculation depended on that. If that’s the case, then just skip them:

  void ofApp::draw() {
    if (ofGetFrameNum() < 6) {
      return;
    }
  }

  Using random values can be tricky if they make the output change constantly, making it really hard to see. One way around this is to force the random output to be the same by setting a known random seed.

  // either do this...
  void ofApp::draw() {
    ofSeedRandom(0); // use 0 or other number
  }
  
  // or this...
  void ofApp::mouseMoved(int x, int y) {
    ofSeedRandom(ofGetElapsedTime()); // only change the random seed when the mouse moves.
  }

  If you are passing a complex class into a function, it needs to made a reference. What is a complex class, you ask? For the technically inclined, it’s any class that stores data on the heap. This is because C++ is pass-by-value by default. This means that a shallow copy of the arguments are passed into the function when they are called.

  If none of that makes sense, remember this: If you see weird results when passing objects to your functions, you need to add an & to the front of your variable name in a function, like below.

  // ofApp.h
  void doThingToImage(ofImage &image); // do this.
  void doThingToImageIncorrect(ofImage image; //do not do this.

  Drawing fonts can be a huge pain. This is because the default ofTrueTypeFont draw(int, int) function draws your text assuming that the arguments define the lower left point of the text bounding box. Furthermore, it is not easy to control the size of the text, and changing text size is clunky. Instead, use getStringBoundingBox to calculate the size of the text, and scale it to a percentage of a screen.

  // ofApp.h
  ofPoint center;
  ofTrueTypeFont font;
  ofRectangle bounds;
  float textToScreenWidthRatio;
  
  
  // ofApp.cpp
  // get the center of the screen as a point
  center.set(ofGetWidth()/2, ofGetHeight()/2);
  // load font at really large size
  font.load("AkzidenzGrotesk-BoldExtended.otf", 1000);
  bounds = font.getStringBoundingBox("hello", 0, 0);
  textToScreenWidthRatio = ofGetWidth() / bounds.width;
  
  // when drawing later...
  ofPushMatrix();
  ofTranslate(center.x - (bounds.width/2 + bounds.x) * textToScreenWidthRatio,
              center.y + (bounds.height/2) * textToScreenWidthRatio);
  ofScale(textToScreenWidthRatio, textToScreenWidthRatio);
  font.draw("hello", 0, 0);
  ofPopMatrix();

  The following code centers the text in the middle and draws it so that its horizontal edges lines up with the edge of the screen. By adjusting textToScreenWidthRatio, you can draw texts for any arbitary size.

• Required reading for writing emphasis in New Media Studies

  27 October 2017

  Brevity is the soul of wit. - Hamlet

  My experiences as a programmer has led me to believe that programming languages that are more syntactically concise are much more powerful. I didn’t come up with that, see Yegge, Graham or Miller.

  That being said, I still struggled with the words used in art theory writings, which we studied as part of SFPC. Take some of these sample sentences

  Irony is about contradictions that do not resolve into larger wholes, even dialectically, about the tension of holding incompatible things toegether because both or all are necessary and true.

  The development of productive forces has been the real unconcious history which built and modified the conditions of survival, and extended those conditions: the economic basis of all their undertakings.

  These are taken out of readings that are important in art theory and whose authors I have deep respect for. That being said, I think that they are still superfluous, and could use some editing.

  This might be somewhat circuitous, but it was an inspiration for my final project for SFPC’s code poetry track. Using simple rules to morph suffixes for words, I generated a fictional list of art theory terms that I often stumbled over in readings. Here is a sample output:

  The Social Of The Psychology And The Psychologization Of Psychologies
  The History Of The Gender In The Context Of The Archeology Of Machines
  The Sociologization of Structuralism
  The De-Fundamentalization of Reductionism

  These were made using base words such as structural, sociology, or reduction, and morphing their endings, creating words like structuralization, sociologisms, or reductionstic.

  I struggle with this project because I feel that these words have valid uses sometimes, and I don’t wish to discredit the use of this words to elucidate delicate concepts. However, I do feel that most of the time these words are a writing style and that by writing in this manner, it only serves to exclude those not in art theory circles. How can we write in a way that is both brief and inclusive?

  I have a feeling that one day I might look back on this work and be very embarassed about it, but it marks a point in my life where I begin to engage with art theory as a way of understanding my life and my work.

  If you’re interested, we made a library of readings and references for art theory as part of SFPC called The Radical Outside.

Page: 1 of 5 >

subscribe via RSS