Besides a text-rendering addon I created addon for the streaming twitter server... I'm still working on this and need to fine tune some things before I can make it publicly avaible in such a way it can be used by others.

Below are some images of little projects I'm working on.

We created a design to drive a shiftregister. The PCB is okay, though not the best ever quality, but for a first time we're really happy. Next step is to solder it nicely and make it work to drive our 7-segmented LEDs.

About my "Math++" moment... the sea anemones paper talks about the locality of a change. What's that, I hear you say. Imagine a grass stalk (stalk A) with a tiny curle at the very end of the stalk. Imagine another stalk (stalk B) where the curle starts at the root and finishes at the tip. You can say that the curliness of the the stalk A is more local than the one of stalk B. The nice thing is that you can use the C++/math function pow(base, exponent) to define this "localness".

In the images below you can see a stem which uses around 40 separate segments. Each segment gets an index value and the more towards the tip of the stalk the higher this index value gets. We use the index number of a segment for the base component of pow(base,component) to specify the position/range of the specific segment in relation to the whole stem. So the base value changes from 0.1 to 0.2, 0.3, 0.4, etc... but the component stays the same which results in the images below!

# --------------------- Stem.cpp -----------------------
#include "Stem.h"
#include "Segment.h"
 
Stem::Stem(int nNumParts) {
    // create segments.
    Segment* parent = NULL;
    Segment* segment = NULL;
    float radius = 55;
    ofxVec2f pos(ofGetWidth()/2, ofGetHeight()-100);
    float angle = -HALF_PI;
    for(int i = 0; i < nNumParts; ++i) {
        bool is_head = (i == nNumParts-1);
        pos.x += cos(angle) * radius;
        pos.y += sin(angle) * radius;
        radius *= 0.90;
        segment = new Segment(pos, angle, i+1,is_head, parent);
        segments.push_back(segment);
        parent = segment;
        angle *= 1.05;
    }
 
}
 
void Stem::draw() {
    vector<Segment*>::iterator it = segments.begin();
    while(it != segments.end()){
        (*it)->draw();
        ++it;
    }
}
 
void Stem::update() {
    vector<Segment*>::iterator it = segments.begin();
    while(it != segments.end()){
        (*it)->update();
        ++it;
    }
}
 
void Stem::curle(float fAngle) {
    vector<Segment*>::iterator it = segments.begin();
    while(it != segments.end()){
        (*it)->curle(fAngle);
        ++it;
    }
}
 
void Stem::setIndexDiv(float fDiv) {
    vector<Segment*>::iterator it = segments.begin();
    while(it != segments.end()){
        (*it)->setIndexDiv(fDiv);
        ++it;
    }
}
 
void Stem::setPow(float fPow) {
    vector<Segment*>::iterator it = segments.begin();
    while(it != segments.end()){
        (*it)->setPow(fPow);
        ++it;
    }
}
 
# --------------------- Segment.cpp -------------------
#include "Segment.h"
Segment::Segment(ofxVec2f oPosition, float fAngle,  float nIndex,bool isHead, Segment* pParent)
:parent(pParent)
,position(oPosition)
,angle(fAngle)
,index(nIndex)
,is_head(isHead)
,length(10)
,index_div(10)
,pow_val(0.6)
{
    if(parent != NULL) {
        length = (parent->position - position).length();
    }
    if(index < 0)
        index = 0.001;
    inverse_index = 1.0f/index;
}
 
void Segment::curle(float fAngle) {
    // At the top of the segment, the index value is higher, so as well
    // as the angle change (due to index/index_div). Besides this proportional
    // change in angle per segment, we define the locality of the change
    // using the exponent we pass to pow(). 
    // The bigger the pow_val change the more local the change
    // will .. note that the base value of pow also increases for each
    // segment near the top.
    float t = index/index_div;
    angle = (fAngle) * pow(index/index_div,pow_val);
    if(parent != NULL) {
        position.x = parent->position.x + cos(angle - HALF_PI) * length;
        position.y = parent->position.y + sin(angle - HALF_PI) * length;
    }
}
 
void Segment::draw() {
    if(parent != NULL) {
        glColor4f(1.0f, 1.0f, 0.6f,0.8f);
        ofCircle(position.x, position.y,2.5);
 
        glColor4f(0.0f, 1.0f, 0.2f, 0.8f);
        glBegin(GL_LINES);
            glVertex2fv(position.v);
            glVertex2fv(parent->position.v);
        glEnd();
    }
    if(is_head) {
        glColor4f(1.0f, 1.0f, 0.6f,0.8f);
        ofCircle(position.x, position.y,2.5);
    }
}
 
void Segment::update() {}
 
void Segment::setIndexDiv(float fDiv) {
    index_div = fDiv;
}
 
void Segment::setPow(float fPow) {
    pow_val = fPow;
}

Some green...

And with some fishes!

Read more to see some of the posts we did on piratepad

SLIDES OF THE MORNING TUTORIAL
http://companje.nl/openframeworks/
 
Things learnt during the Open Frameworks workshop at SETUP
 
MORNING TUTORIAL
 
In the morning we were working on a basic bouncing balls tutorial. Here are the final files that we worked on:
 
http://piratepad.nl/testApp-cpp
http://piratepad.nl/testApp-h
 
 
CONTROL PANEL
 
Remember that spiffy control panel?
http://github.com/ofTheo/ofxControlPanel
 
 
IMAGE PROCESSING
 
Did you know there was a guy called Alfred Haar who was an incredible nerd already back in 1909? In Open Frameworks there is an extention of OpenCV's capabilities called OFXCVHaarfinder (Open Frameworks eXtention Computer Vision Haarfinder). This is a general image recognition library. It's general in the sense that you can teach it to recognise anything by training it. Show it a lot of faces, and it will start finding them after the training period.
 
When Sebastian told us about it, we thought he was talking about tracking hair..
 
Here you can download the extention to the OpenCV addon:
http://code.google.com/p/kyle/
 
More about Alfred Haar:
http://en.wikipedia.org/wiki/Alfréd_Haar
 
FLOW DETECTION! <-- google this!
 
One step further is working with Haar-Cascades. These are XML files that describe how detected objects are related to eachother. This make complicated relatios possible. For example, an arm should be attached to a body, which should be attached to a face, etc.
 
A list of XML files:
https://opencvlibrary.svn.sourceforge.net/svnroot/opencvlibrary/tags/latest_tested_snapshot/opencv/data/haarcascades/
 
More on the Open Frameworks Forum:
http://www.openframeworks.cc/forum/viewtopic.php?f=10&t=2006&hilit=haar
 
Some piratepads we used:
http://piratepad.nl/haarfinder
http://piratepad.nl/facedetection
 
Final code that Sebastian created:
http://www.sendspace.com/file/uws6p9
 
AUDIO SYNTHESIS ADD-ON
 
http://www.maximilian.strangeloop.co.uk/
Andre Michelle's Pulsate; http://lab.andre-michelle.com/pulsate
 
Fancy opengl particle stuff from Sebastian:
http://www.sendspace.com/file/rjgilt
 
Basicly an extended opencv example that throws particle at the blobs :-)
To get it running, copy the opencv example and paste the files.
 
ShadowFighter
peteruithoven.nl/shadowfighter/

Last Sunday I came back from the OF-lab and went to another workshop at Philips Lighting on Monday and Tuesday for which we are doing a project. We had a room in the fantastic Art Hotel just next the Philips building. They toilet and bath-tub were... well enormous.. like a swimming pool :). From Wednesday until today (Sunday) Martin and I have been working on our new office (see the other post for some pictures), which is gonna be an amazing place!

The only comparable library is openFrameworks and it seems that Cinder aims at programmers with a bit more knowledge about openGL and C++. Event handling seems similar, the general application flow is similar to openFrameworks (prepareSettings() → setup(), draw() → draw(), update() → update(), etc..). Though I notice one big difference; when I look at the Cinder code I see lots of direct openGL calls which one does not see in openFrameworks very often (at least not directly). Personally I like Cinders approach, though this is probably because I've been using openGL calls directly instead of openFrameworks wrapper functions (ofCircle/ofLine, etc..) as I needed to learn openGL.

The examples (46) which are shipped with Cinder are amazing! Some of these examples have been created by Robert Hodgins which are beautiful and it's nice to peek around in his code and learn from the "master". There are many many more examples with some not-so-basic examples like shaders, voronoi, bump mapping, etc.. which are definitely worth checking out.

So if you're into creative coding make sure you download this library and give it a try!

Here are some screenshots of the example applications

Chuck form AIXIZ told me that one can connect the 780nm 25mW 5VDC infrared laser directly to +5v. When you connect your laser, make sure to use a stabilized power supply, or use a LM7805 to stabilze the input. When you use a LM7805, make sure you set your power supply to a voltage which is a higher than 5v so the LM780 can stabilize it.

• http://nuigroup.com/forums/viewthread/8650/
• http://nuigroup.com/forums/viewthread/9386/

Together with Tim, Rick , Martin, Theo and myself we had a very nice, spontaneous oF FreakDay.

To get more particles in my system with a reasonable framerate (above 30fps), we need to find a way to decrease the number of particle-particle interaction without loss losing the visual effect. Well thankfully I don't have to come up with this myself as Barnes Hut created a algorithm which does exactly that! The general idea behind this solution is described on this lecture on Barnes Hut.

Kyle McDonald created an implemenation of this algorithm that you can download from google code. I need to tune this code in such a way that I can use my Coulomb forces to get the nice magnetic interaction I got in my previous application. I'll start by implementing the Barnes Hut algorithm for 2D which uses a quad tree data structure.

So I got a pencil and paper and started drawing and trying to understand the quad tree class. The first steps of the Barnes Hut algorithm (BH), is to device all the particles in separate nodes. A node is defined by the positions of the particles. Each node can have a maximum of 4 children which are the sub-squares in a node (as it's called a quad tree, this makes kind of sense). So lets say we got a application with a size of 640x480 and 6 particles randomly positioned in 2D.

Like this

Next step is to create our "root" tree node. We start by creating a new Tree object and start by finding the min_x, min_y, max_x and max_y positions, which are just the four corners of the space in which the particles are positioned. Therefore we need to get access to all the particles. For convenience I stored them in a vector particles, member in my testApp.cpp (see openframeworks). The outer border in the image below shows the space that is confined by the min_x, min_y and max_x, max_y values. So okay, we've got our first single quadrant, what now? Well now we need to create continue to create new Tree nodes as long as there are tree nodes that have more than 1 particle in in. So where do start with that? Well, a rough sketch will be something like this:

In pseudo code

void createTree(vector<Particle*> particles) {
   - for each particle P do 
       - processParticle(P)
  - end loop
}
 
// process the particle and check if we need to create subnodes
void processParticle(Particle* P) {
 
 }

The processParticle() function is tricky as this is where we implement the recursion. First thing I implement when creating a recursive function is the return or stop rule as we don't want our recursion to go on forever. Well, when is a node "ready"? A node is ready when it's is sub-divided into 4 quadrants. But then when do we divide the current node into 4 quadrants. When we think about what we want to accomplish: implement a divide an conquer like algorithm, we need to divide the particles onto the quadrants. Why? I hear you thinking.. well placing the particles into sub nodes is what makes the Barnes Hut algorithm so powerful. An example: lets say you have 10.000 particles and you want to have particle-particle interaction and especially a gravitational force. Also imagine that 9.999 of these particles are position at 400,400 (x,y) and only one particle is positioned at 10,10(x,y). Then, you could of course check each particle against each other particle ... .or you just check the particle at 10,10 against one of the other 9.999 particles.. that's a lot less checks you need to perform. This isn't exactly how BH works, though it's a simpler to see it like this. I'll explain more about BH below.

pseudo code

void ProcessParticle(Particle* P) {
  if(num_children > MAX_CHILDREN_PER_NODE) {
 }
 else {
  // okay we are not yet ready, do some work. 
}
}

So when we do not have 4 children we start working. But what do we actually need to do? At the end we want each node in the tree to have at least one particle OR no particle at all. A node will have no particle when it has sub nodes; so when it's subdivided into four. We need to create subn odes, when we have already 4 particles stored and the 5th particle is given to us. Creating sub nodes involves dividing our space (the min_x, min_y, max_x, max_y) into four separate nodes. For this we need to know what space each of the sub nodes get, well this is not the hardest part so I'll paste the helpers functions down here.

Calculating the center x/y and 4 corner positions

void Tree::squareBoundaries() {
    float center_x = (min_x + max_x)/2;
    float center_y = (min_y + max_y)/2;
    float size_x = max_x - min_x;
    float size_y = max_y - min_y;
    float size = max(size_x, size_y) / 2;
    min_x = center_x - size;
    max_x = center_x + size;
    min_y = center_y - size;
    max_y = center_y + size;
    setCenter();
}
 
// Set center and size
void Tree::setCenter() {
    center_x = (min_x + max_x) / 2;
    center_y = (min_y + max_y) / 2;
    size = max_x - min_x;
}

Now we have these positions and the center of our space, we can create the sub nodes for our children, which is done like this:

**Creating sub nodes (pseude code) **

void ProcessParticle(Particle* P) {
  if(num_children > MAX_CHILDREN_PER_NODE) {
    nw = new Tree(min_x, min_y, center_x, center_y);
    ne = new Tree(center_x, min_y, max_x, center_y);
    sw = new Tree(min_x, center_y, center_x, max_y);
    se = new Tree(center_x, center_y, max_x, max_y);
    has_children = true;
    for(int i = 0; i < num_particles; ++i)
        processParticle(particles[i]);
    num_particles = 0;
    processParticle(pParticle);
  }
  else {
         // okay we are not yet ready, do some work. 
     particles[num_particles] = pParticle;
     num_children++;
     empty = false;
 }
}

As you can see, we first keep track of the particles in an array called "particles". Though when we are separated into 4 other nodes, we pass the particles which were given to us, to one of our sub nodes in such a way that they are placed in the correct quadrant based on the position of each particle. This is where the recursion starts working. This is what we will do for each of the particles that is given to use by the createTree() function. For example, the root node has 4 sub nodes, and those sub nodes also have 4 sub nodes. When we get a new particle, we don't want to add it to our self, but we want to pass it through to our sub nodes. We first check which sub node is responsible for this particle which is done by checking the position of the particle against the rectangle/space each of our sub nodes. Then the sub node also checks if it needs to handle this particle etc.. etc... So at the end each particle is passed along to all of the sub nodes until it cant be divided any more. After that we've got a nice tree with particles!

But, when do we know if we need to pass the particle along to our sub nodes? You can do this by simply checking if you have sub nodes. So therefore we first need to have something where we store sub nodes. As you probably already saw, we have four members called "nw, ne, sw and se" that are of the same type as the main node (Tree). In pseudo code, we would add something like this to the processParticle() function:

Pseudo code: check if we need to pass the particle to one of our sub nodes

void ProcessParticle(Particle* P) {
 if(nw != NULL && ne != NULL) {
       // pass the particle to one of the quadrants. Pass it to the quadrant which is responsible for the space where the particle is placed. 
       ofxVec3f pos = pParticle->position;
    if(pos.x < center_x) {
        if(pos.y < center_y) 
            nw->addParticle(pParticle);
        else 
            sw->addParticle(pParticle);
    }
    else {
        if(pos.y < center_y)
            ne->addParticle(pParticle);
        else 
            se->addParticle(pParticle);
    }
}
else {
  // continue to populate ourself
   if(num_children > MAX_CHILDREN_PER_NODE) {
    nw = new Tree(min_x, min_y, center_x, center_y);
    ne = new Tree(center_x, min_y, max_x, center_y);
    sw = new Tree(min_x, center_y, center_x, max_y);
    se = new Tree(center_x, center_y, max_x, max_y);
    has_children = true;
    for(int i = 0; i < num_particles; ++i)
        processParticle(particles[i]);
    num_particles = 0;
    processParticle(pParticle);
  }
  else {
         // okay we are not yet ready, do some work. 
     particles[num_particles] = pParticle;
     num_children++;
     empty = false;
 }
}
}

In Kyles implementation he uses a member "hasChildren" instead of using the sub node members (nw,ne,sw,se) to check if we need to pass the particle to one of our sub nodes. This is totally okay and I only didn't do it here to keep the code as clear as possible.

Pffffeww this was the first part of the algorithm: creating the tree structure.

In a couple of weeks I'll continue with the next steps of the Barnes Hut algorithm.

I'm using Coulomps law to create hundred particles which have a charge. In the center of these particles there's the center of gravity. All particles are attracted to this center point, but they also keep a distance from each other based on the their chage and the force I calculate using Coulomb's law. Note that this is a my implementation of Coulomb's law, where I use 10 for the constant which you can change if you want more or less attraction.

float c = 10.0 * charge * pMagnet->getCharge() / (r*r);
ofxVec3f dir_tmp = dir;
float aa = c/mass;
dir_tmp.normalize().scale(aa);
 
velocity.x += dir_tmp.x;
velocity.y += dir_tmp.y;

So in short this effect is created in 3 simple steps:

• Loop over all particles and let each particle move towards or away from all the other particles based on Coulombs law.
• When all particles have reacted on the other particles using the Coulombs law, we gravitate towards a center particle. I'm only using the center particle to get the position of it, so I know towards I need to attract it. It's important that we add a bit of simple drag in this gravitate() function (like velocity *= 0.96) as we want to particles to come to rest slowly. Without this drag the particles will bounce around only.
• Then the last step is to update the position of the particles (position += velocity) and that's it.

The particle class

#include "Particle.h"
Particle::Particle(ofxVec3f oPosition, float fMass, ofImage oImage, ofImage oShineImage)
    :position(oPosition)
    ,img(oImage)
    ,mass(fMass) 
    ,attract(true)
    ,enabled(true)
    ,charge(1.0f)
    ,shine_img(oShineImage)
{
 
    img.setAnchorPoint(img.getWidth()/2,img.getHeight()/2); 
    inverse_mass = 1/fMass;
}
 
void Particle::disable() {
    enabled = false;
}
 
void Particle::enable() {
    enabled = true;
}
 
bool Particle::isEnabled() {
    return enabled;
}
 
void Particle::draw() {
    vector<Shine*>::iterator it = shines.begin();
    while(it != shines.end()) {
 
        if((*it)->isDead()) {
            delete (*it);
            it = shines.erase(it);
 
        }
        else {
            (*it)->position = position;
            (*it)->draw();
            ++it;
        }
 
 
    }
 
    if (charge <= 2.0f) {
        if(enabled) {
            glColor4f(0.1,1.,.1,.8);
        }
        else{
            glColor4f(1,0.0,0.0,.8);
        }
        glColor4f(1.0, 1.0, 1.0, .8);
    }
    else {
        glColor4f(0.1,1.,.1,1.0);
    }
    img.draw(position.x, position.y);
}
 
void Particle::update() {
    if(!enabled)
        return;
    position += velocity;
}
 
void Particle::addForce(ofxVec3f oForce) {
    forces += (oForce*inverse_mass);
}
 
float Particle::getMass() {
    return mass;
}
 
ofxVec3f Particle::getPosition() {
    return position;
}
 
void Particle::setPosition(ofxVec3f oPos) {
    position = oPos;
}
 
float Particle::getCharge() {
    return charge;
}
void Particle::setCharge(float fCharge) {
    charge = fCharge;
}
void Particle::gravitate(Particle* pTo) {
    // gravitational force
    ofxVec3f dir = pTo->getPosition() - position;
    float f = (pTo->attract) ? 0.6 : -0.3;
    dir.normalize().scale(f); // the higher gravitational attraction, the faster the particles are attracted to the center. Tested values: 0.1 - 0.8
    velocity *= 0.91;  // the particles are first attracted by magnetic forces, then gravitated. We need to implement this simple drag force because else the particles will "explode". Tested values: 0.91 - 0.99
    velocity.x += dir.x;
    velocity.y += dir.y;
}
 
void Particle::testMagnet(Particle* pMagnet) {
    if(pMagnet == this) {
        return;
    }
    // coulombs law
    ofxVec3f dir =  position -  pMagnet->getPosition();
    ofxVec3f dir2 = dir;
    float r = dir.length();
    float e = charge/(r*r);
    if(e > 0.01)
        e = 0.01;
    else if(e < -0.01)
        e = -0.01;
 
    if(r < 20 && shines.size() < 3) {
        shines.push_back(new Shine(shine_img, 40));
    }
 
    /* 
    Coulomb law implementation  (roxlu: see thsi page: http://processing.org/discourse/yabb/YaBB.cgi?board=Contribution_Simlation;action=display;num=1082567431, where they talk about electric fields but if I'm correct it's just coulombs law)
    ===========================
    float c = 10.0 * charge * pMagnet->getCharge() / (r*r);
    ofxVec3f dir_tmp = dir;
    float aa = c/mass;
    dir_tmp.normalize().scale(aa);
 
    velocity.x += dir_tmp.x;
    velocity.y += dir_tmp.y;
    */
 
    float f = charge * e;
    float a = f/mass * 60.0; // the acceleration, the higher the bigger influence the magnetic forces have on each of the particles.s
    dir.normalize().scale(a);
    velocity.x += dir.x;
    velocity.y += dir.y;
 
 
    /*
 
    coulomps force
    ==============
    F = k * q1 * q2 / r^2
 
    gravity
    =======
    f = G * mass1 * mass2 / distance^2
 
 
     magnetism (lorentz)
     ====================
 
     E = [some constant] * (q / r^2)
     E = electrical field value
     q = charge of particle generating the field.
     r = distance to the charged particle (which is the magnet)
 
     Fb = Q * E  
     Fb = magnetic force
     Q = charge of particle itself
 
 
     for (var i:uint=0; i<totalSent; i++){
            if (i != index){
                    R           = getDistance(particles[i].getX, particles[i].getY, _x, _y);
                    E           = ye[i].getQ/(R*R);
                    if (E < -0.01){
                        E       = -0.01;
                    } else if (E > 0.01){
                        E       = 0.01;
                    }
                    F           = Q * E;
                    A           = F/M * 10;
                    Angle       = getAngle(particles[i].getX, particles[i].getY, _x, _y);
 
                    xv          += Math.cos(Angle) * A;
                    yv          += Math.sin(Angle) * A;
            }
        }
*/   
 
}

Flights 404 code

class MagneticParticle {
  GravityField gravity;
  int index;
  float x, y;
  float xv, yv;
  float E, R, F, P, A, Angle, Q, M;
  float gAngle;
  float gTheta;
  float gxv;
  float gyv;
 
  MagneticParticle (int indexSent, float xSent, float ySent, GravityField gravitySent){
    index      = indexSent;
    x          = xSent;
    y          = ySent;
    gravity    = gravitySent;
    M          = 1.0;
    Q          = 1.0;
    xv         = random(-.5, .5);
    yv         = random(-.5, .5);
  }
 
  void field(){
    for (int i=0; i<totalParticles; i++){
      if (i != index){
        R          = dist(particles[i].x, particles[i].y, x, y);
        E          = constrain(particles[i].Q/(R*R), -0.01, 0.01);
        F          = Q * E;
        A          = F/M * 10.0;
 
        Angle      = atan2(y - particles[i].y, x - particles[i].x);
 
        xv         += cos(Angle) * A;
        yv         += sin(Angle) * A;
      }
    }
 
    xv *= .96;
    yv *= .96;
  }
 
 
  void applyGravity(){
    gAngle         = atan2(gravity.y - y, gravity.x - x);
    gxv            = cos(gAngle) * gravity.Q;
    gyv            = sin(gAngle) * gravity.Q;
    xv            += gxv;
    yv            += gyv;
  }
 
  void move(){
    x             += xv;
    y             += yv;
  }
 
  void render(){
    stroke(0);
    line(x-1, y, x+1, y);
    line(x, y-1, x, y+1);
  }
}

Using this board you can program as much attinies as you want and use those in your project. Programming an attiny2313 is kind of similar as programming the Arduino. The nice thing about this design is that you can create your own "arduino" like board for a 10th of the costs. You can also program those nice attiny45.

How it works

You create a group with a name like "footer", then in that group you create layers with names like "logo", "counter" etc.. The addon will export the layers to files, which get the name from the group and the layer, so: "footer_logo.png", "footer_counter.png" etc. The addon only works for one level deep layers. So when you don't want to export some layers put them in a 2nd level layer set.

Installation (Mac, will also work on Windows)

Download the file below and copy it to your Applications\Adobe Photoshop CS4\Presets\Scripts directory and restart photoshop.

Download export_layer_to_png.zip

• Turn power off
• Make sure the paper tray is full and the toner+drum are in the printer
• Push the GO button and turn on the device
• Wait until all 3 lights are lit, then release the GO button
• Press the GO button twice
• All lights turn solid
• With all solid, press GO 6 times
• Ready light goes red
• Close front panel and you're ready
• Not necessary: press 3 times to get a print page with statistics.

Some articles on 3D billboarding:

• NeHe billboarding
• LightHouse billboarding

Of course when one knows how to do this it's easy... but you have to understand the concept. A big mistake I made was using 'world' values for the position of the particles when I rotated them. This was easily solved by removing the particle position from the four vec3 positions of the QUAD and then using something like:

void Particle::draw() {
glPushMatrix();
 
  glTranslatef(particle_position.x, particle_position.y, particle_position.z);
  glRotate(angle, normal.x, normal.y, normal.z);
  glVertex3f(p1.x, p1.y, p1.z);
  glVertex3f(p2.x, p2.y, p2.z);
  glVertex3f(p3.x, p3.y, p3.z);
  glVertex3f(p4.x, p4.y, p4.z);
 
glPopMatrix();

When you look at the code and the image, these are the values what the variable represent (they are mostly vector3 objects):

• p1 - p4: The yellow dots
• normal: The green arrow
• particle_position: The red dot

The code above rotates the p1-p4 vertices around the given angle and normal axis. So what i learned from this is probably what I already knew ... Use one vector3 member for a 3D object (could be a particle used to draw a texture, a sphere, trail of particles to create a creature for your flocking). when you want to draw something at the position of this vector3 use glTranslate to move towards this position and glRotatef to rotate your object. After calling glTranslate/glRotate draw your 3D object using the local coordinates of your 3D model.

Below is an image I used to get make it a bit more clear for me.

What you need

• arduino ide version 0.018 - download
• mega-isp version 0.3 - download
• avrdude version 5.10. Download WinAVR version 2010.01.10 which includes avrdude for windows.

Installation

Arduino
Simply unpack the arduino zip file. Copy the arduino-0018 directory to a place you like, I used C:\Program Files\arduino-0018

Mega-isp
Unpack the zip which contains the avrisp.pde file. This is the Arduino project file which you need to burn to your Arduino.

WinAVR

• Follow the installation wizard
• Add the binary path to your system PATH variable. On windows, I used the default installation directory (C:\WinAVR-20100110\bin). By adding this to your PATH environment variable you're able to execute the "avrdude" command from any CMD window, in any path. Google for a description on how to set your PATH environment variable.

The hardware

Okay, when you've downloaded and installed all necessary files you're ready to create your circuit. But first some info, so you know what you're doing. Using the AAAA-toolchain you use the arduino to program another AVR chip. The arduino uses ICSP (in circuit serial programming) for this. Basically this means that you need to connect a couple of wires from the arduino to your AVR chip (attiny2313). We need to connect the standard MOSI, MISO, SCK, RST wires for ICSP. Use this wiring:

Programming wires

Prepping the Arduino

Start the Arduino IDE and open the avrisp.pde file you downloaded before. Connect your Arduino, select the correct board and COM port and upload the avr-isp code to the arduino. I'll not explain this more thoroughly as it's basic arduino programming. When you've uploaded avrisp to the arduino you're ready to create the "hello world", blinking led application to test this avr-isp programming method.

Programming the attiny2313

When you want to program your attiny2313, you need to understand that we use different steps to get the program-code on the chip. To program the attiny2313 you need to use "avrdude", which is also used by Arduino (under the hood, if I'm correct). AVRDude is able to put the program-code on the chip using the avrisp programming method. WinAVR is set of tools you need to program an attiny (or other avr) without Arduino, using avrdude. The steps you need to take are:

● write the application code in C
● compile the code for the attiny2313 chip using avr-gcc
● upload the compiled code (hex file) to your attiny2313 using avrdude

Application code
I just googled for a attiny2313 blinking led example that I'll use. Connect pin 12 of your attiny2313 to a led with a current limiting resistor. Copy and paste this code in a file named blinking_led_2313.c.

#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
 
int main(void) {
    DDRB |= 1<<PB0; /* set PB0 to output */
    while(1) {
        PORTB &= ~(1<<PB0); /* LED on */
        _delay_ms(100);
        PORTB |= 1<<PB0; /* LED off */
        _delay_ms(900);
    }
    return 0;
}

Compile the code to a hex file
Create a new file in the same directory of your blinking_led_2313.c file with the name "Makefile" and put this code in it (see below). You can easily reuse this makefile for other projects by changing the "PRJSRC" variable.

# See: http://electrons.psychogenic.com/modules/arms/view.php?w=art&idx=8&page=2
##### This Makefile will make compiling Atmel AVR 
##### micro controller projects simple with Linux 
##### or other Unix workstations and the AVR-GCC 
##### tools.
#####
##### It supports C, C++ and Assembly source files.
#####
##### Customize the values as indicated below and :
##### make
##### make disasm 
##### make stats 
##### make hex
##### make writeflash
##### make gdbinit
##### or make clean
#####
##### See the http://electrons.psychogenic.com/ 
##### website for detailed instructions
 
 
####################################################
#####                                          #####
#####              Configuration               #####
#####                                          #####
##### Customize the values in this section for #####
##### your project. MCU, PROJECTNAME and       #####
##### PRJSRC must be setup for all projects,   #####
##### the remaining variables are only         #####
##### relevant to those needing additional     #####
##### include dirs or libraries and those      #####
##### who wish to use the avrdude programmer   #####
#####                                          #####
##### See http://electrons.psychogenic.com/    #####
##### for further details.                     #####
#####                                          #####
####################################################
 
 
#####         Target Specific Details          #####
#####     Customize these for your project     #####
 
# Name of target controller 
# (e.g. 'at90s8515', see the available avr-gcc mmcu 
# options for possible values)
MCU=attiny2313
 
# Name of our project
# (use a single word, e.g. 'myproject')
PROJECTNAME=blinking_led_2313
 
# Source files
# List C/C++/Assembly source files:
# (list all files to compile, e.g. 'a.c b.cpp as.S'):
# Use .cc, .cpp or .C suffix for C++ files, use .S 
# (NOT .s !!!) for assembly source code files.
PRJSRC=blinking_led_2313.c
 
# additional includes (e.g. -I/path/to/mydir)
INC=
 
# libraries to link in (e.g. -lmylib)
LIBS=
 
# Optimization level, 
# use s (size opt), 1, 2, 3 or 0 (off)
OPTLEVEL=s
 
 
#####      AVR Dude 'writeflash' options       #####
#####  If you are using the avrdude program
#####  (http://www.bsdhome.com/avrdude/) to write
#####  to the MCU, you can set the following config
#####  options and use 'make writeflash' to program
#####  the device.
 
 
# programmer id--check the avrdude for complete list
# of available opts.  These should include stk500,
# avr910, avrisp, bsd, pony and more.  Set this to
# one of the valid "-c PROGRAMMER-ID" values 
# described in the avrdude info page.
# 
AVRDUDE_PROGRAMMERID=avrisp
 
# port--serial or parallel port to which your 
# hardware programmer is attached
#
AVRDUDE_PORT=com12
 
 
####################################################
#####                Config Done               #####
#####                                          #####
##### You should not need to edit anything      #####
##### below to use the makefile but may wish   #####
##### to override a few of the flags           #####
##### nonetheless                              #####
#####                                          #####
####################################################
 
 
##### Flags ####
 
# HEXFORMAT -- format for .hex file output
HEXFORMAT=ihex
 
# compiler
CFLAGS=-I. $(INC) -g -mmcu=$(MCU) -O$(OPTLEVEL) \
    -fpack-struct -fshort-enums             \
    -funsigned-bitfields -funsigned-char    \
    -Wall -Wstrict-prototypes               \
    -Wa,-ahlms=$(firstword                  \
    $(filter %.lst, $(<:.c=.lst)))
 
# c++ specific flags
CPPFLAGS=-fno-exceptions               \
    -Wa,-ahlms=$(firstword         \
    $(filter %.lst, $(<:.cpp=.lst))\
    $(filter %.lst, $(<:.cc=.lst)) \
    $(filter %.lst, $(<:.C=.lst)))
 
# assembler
ASMFLAGS =-I. $(INC) -mmcu=$(MCU)        \
    -x assembler-with-cpp            \
    -Wa,-gstabs,-ahlms=$(firstword   \
        $(<:.S=.lst) $(<.s=.lst))
 
 
# linker
LDFLAGS=-Wl,-Map,$(TRG).map -mmcu=$(MCU) \
    -lm $(LIBS)
 
##### executables ####
CC=avr-gcc
OBJCOPY=avr-objcopy
OBJDUMP=avr-objdump
SIZE=avr-size
AVRDUDE=avrdude
REMOVE=rm -f
 
##### automatic target names ####
TRG=$(PROJECTNAME).out
DUMPTRG=$(PROJECTNAME).s
 
HEXROMTRG=$(PROJECTNAME).hex 
HEXTRG=$(HEXROMTRG) $(PROJECTNAME).ee.hex
GDBINITFILE=gdbinit-$(PROJECTNAME)
 
# Define all object files.
 
# Start by splitting source files by type
#  C++
CPPFILES=$(filter %.cpp, $(PRJSRC))
CCFILES=$(filter %.cc, $(PRJSRC))
BIGCFILES=$(filter %.C, $(PRJSRC))
#  C
CFILES=$(filter %.c, $(PRJSRC))
#  Assembly
ASMFILES=$(filter %.S, $(PRJSRC))
 
 
# List all object files we need to create
OBJDEPS=$(CFILES:.c=.o)    \
    $(CPPFILES:.cpp=.o)\
    $(BIGCFILES:.C=.o) \
    $(CCFILES:.cc=.o)  \
    $(ASMFILES:.S=.o)
 
# Define all lst files.
LST=$(filter %.lst, $(OBJDEPS:.o=.lst))
 
# All the possible generated assembly 
# files (.s files)
GENASMFILES=$(filter %.s, $(OBJDEPS:.o=.s)) 
 
 
.SUFFIXES : .c .cc .cpp .C .o .out .s .S \
    .hex .ee.hex .h .hh .hpp
 
 
.PHONY: writeflash clean stats gdbinit stats
 
# Make targets:
# all, disasm, stats, hex, writeflash/install, clean
all: $(TRG)
 
disasm: $(DUMPTRG) stats
 
stats: $(TRG)
    $(OBJDUMP) -h $(TRG)
    $(SIZE) $(TRG) 
 
hex: $(HEXTRG)
 
 
writeflash: hex
    $(AVRDUDE) -c $(AVRDUDE_PROGRAMMERID)   \
     -p $(MCU) -P $(AVRDUDE_PORT) -e        \
     -b 19200 \
     -U flash:w:$(HEXROMTRG)
 
install: writeflash
 
$(DUMPTRG): $(TRG) 
    $(OBJDUMP) -S  $< > $@
 
 
$(TRG): $(OBJDEPS) 
    $(CC) $(LDFLAGS) -o $(TRG) $(OBJDEPS)
 
 
#### Generating assembly ####
# asm from C
%.s: %.c
    $(CC) -S $(CFLAGS) $< -o $@
 
# asm from (hand coded) asm
%.s: %.S
    $(CC) -S $(ASMFLAGS) $< > $@
 
 
# asm from C++
.cpp.s .cc.s .C.s :
    $(CC) -S $(CFLAGS) $(CPPFLAGS) $< -o $@
 
 
 
#### Generating object files ####
# object from C
.c.o: 
    $(CC) $(CFLAGS) -c $<
 
 
# object from C++ (.cc, .cpp, .C files)
.cc.o .cpp.o .C.o :
    $(CC) $(CFLAGS) $(CPPFLAGS) -c $<
 
# object from asm
.S.o :
    $(CC) $(ASMFLAGS) -c $< -o $@
 
 
#### Generating hex files ####
# hex files from elf
#####  Generating a gdb initialisation file    #####
.out.hex:
    $(OBJCOPY) -j .text                    \
        -j .data                       \
        -O $(HEXFORMAT) $< $@
 
.out.ee.hex:
    $(OBJCOPY) -j .eeprom                  \
        --change-section-lma .eeprom=0 \
        -O $(HEXFORMAT) $< $@
 
 
#####  Generating a gdb initialisation file    #####
##### Use by launching simulavr and avr-gdb:   #####
#####   avr-gdb -x gdbinit-myproject           #####
gdbinit: $(GDBINITFILE)
 
$(GDBINITFILE): $(TRG)
    @echo "file $(TRG)" > $(GDBINITFILE)
 
    @echo "target remote localhost:1212" \
                        >> $(GDBINITFILE)
 
    @echo "load"        >> $(GDBINITFILE) 
    @echo "break main"  >> $(GDBINITFILE)
    @echo "continue"    >> $(GDBINITFILE)
    @echo
    @echo "Use 'avr-gdb -x $(GDBINITFILE)'"
 
 
#### Cleanup ####
clean:
    $(REMOVE) $(TRG) $(TRG).map $(DUMPTRG)
    $(REMOVE) $(OBJDEPS)
    $(REMOVE) $(LST) $(GDBINITFILE)
    $(REMOVE) $(GENASMFILES)
    $(REMOVE) $(HEXTRG)
 
 
 
#####                    EOF                   #####

After you've created this Makefile in the same directory as your blinking_led_2313.c file, open a CMD window and go to that directory where the makefile is located. Then type make (but be sure you've closed the Arduino-IDE before doing so!!).

Upload the code to the chip

In the same CMD window type: make install and you should see a blinking LED in a couple of seconds.

Some helpfull links

http://dddanmar.net/
blinking led

Extra

MCU names for avr-gcc

avr2
at90s2313
at90s2323
at90s2333
at90s2343
attiny22
attiny26
at90s4414
at90s4433
at90s4434
at90s8515
at90c8534
at90s8535
at86rf401
attiny13
attiny2313
avr3
atmega103
atmega603
at43usb320
at43usb355
at76c711
avr4
atmega8
atmega48
atmega88
atmega8515
atmega8535
avr5
atmega16
atmega161
atmega162
atmega163
atmega165
atmega168
atmega169
atmega32
atmega323
atmega325
atmega3250
atmega64
atmega645
atmega6450
atmega128
at90can128
at94k
avr1
at90s1200
attiny11
attiny12
attiny15
attiny28

Then, after I've calculated the positions for the points I create rectangles, actually just openGL GL_QUADS, but using the crossproduct to get the perpendicular lines/positions that make up de quad. When I've got the positions of the QUADs I use an alpha transparent image and put that as a texture on it.

Calculating the points for the quad
Below is the code I've used to calculate the vertices for the QUAD. I'm not sure if this is the best solution, but it works perfect!

void TestQuad::draw() {
    ofEnableAlphaBlending();
 
 
    glBegin(GL_LINE_STRIP);
    for(int i = 0; i < tail.size(); ++i) {
        float a = ((float)tail.size()-i)/(float)tail.size() * .2;
        glColor4f(1.0, 0.0, 0.6,a);
        glVertex3f(tail.at(i).x, tail.at(i).y, tail.at(i).z);
    }
    glEnd();
 
    ofxVec3f normal = position - center;
    ofxVec3f up_vec(0,1,0);
    ofxVec3f p1 = normal.getCrossed(up_vec).normalize().scale(size);
    ofxVec3f p2 = normal.getCrossed(p1).normalize().scale(size);
    ofxVec3f p3 = normal.getCrossed(p2).normalize().scale(size);
    ofxVec3f p4 = normal.getCrossed(p3).normalize().scale(size);
    ofxVec3f pp1 = position+p1;
    ofxVec3f pp2 = position+p2;
    ofxVec3f pp3 = position+p3;
    ofxVec3f pp4 = position+p4;
 
 
    glColor4f(1.0,1.0,1.0,0.9f);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D,texture_id);
 
    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex3f(pp1.x, pp1.y, pp1.z);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(pp2.x, pp2.y, pp2.z);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(pp3.x, pp3.y, pp3.z);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(pp4.x, pp4.y, pp4.z); 
    glEnd();
    glDisable(GL_TEXTURE_2D);
}

Distributing points on a sphere

// from: http://local.wasp.uwa.edu.au/~pbourke/geometry/spherepoints/
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
 
/*
   Create N points on a sphere aproximately equi-distant from each other
   Basically, N points are randomly placed on the sphere and then moved
   around until then moved around until the minimal distance between the
   closed two points is minimaised.
   Paul Bourke, July 1996
*/
 
#define ABS(x) (x < 0 ? -(x) : (x))
 
typedef struct {
  double x,y,z;
} XYZ;
 
void Normalise(XYZ *,double);
double Distance(XYZ,XYZ);
 
/*
   Called with three arguments, the number of points to distribute, the
   radius of the sphere, and the maximum number of iterations to perform.
*/
int main(argc,argv)
int argc;
char **argv;
{
   int i,j,n;
   int counter = 0,countmax = 100;
   int minp1,minp2;
   double r,d,mind,maxd;
   XYZ p[1000],p1,p2;
 
   /* Check we have the right number of arguments */
   if (argc < 4) {
      fprintf(stderr,"Usage: %s npoints radius niterations\n",argv[0]);
      exit(0);
   }
   if ((n = atoi(argv[1])) < 2)
      n = 3;
   if ((r = atof(argv[2])) < 0.001)
      r = 0.001;
   if ((countmax = atoi(argv[3])) < 100)
      countmax = 100;
 
   /* Create the initial random cloud */
   for (i=0;i<n;i++) {
       p[i].x = (rand()%1000)-500;
       p[i].y = (rand()%1000)-500;
       p[i].z = (rand()%1000)-500;
       Normalise(&p[i],r);
    }
 
    while (counter < countmax) {
 
        /* Find the closest two points */
        minp1 = 0;
        minp2 = 1;
        mind = Distance(p[minp1],p[minp2]);
        maxd = mind;
        for (i=0;i<n-1;i++) {
            for (j=i+1;j<n;j++) {
                if ((d = Distance(p[i],p[j])) < mind) {
                   mind = d;
                   minp1 = i;
                   minp2 = j;
                }
                if (d > maxd)
                   maxd = d;
            }
        }
 
        /*
           Move the two minimal points apart, in this case by 1%
           but should really vary this for refinement
        */
        p1 = p[minp1];
        p2 = p[minp2];
        p[minp2].x = p1.x + 1.01 * (p2.x - p1.x);
        p[minp2].y = p1.y + 1.01 * (p2.y - p1.y);
        p[minp2].z = p1.z + 1.01 * (p2.z - p1.z);
        p[minp1].x = p1.x - 0.01 * (p2.x - p1.x);
        p[minp1].y = p1.y - 0.01 * (p2.y - p1.y);
        p[minp1].z = p1.z - 0.01 * (p2.z - p1.z);
        Normalise(&p[minp1],r);
        Normalise(&p[minp2],r);
 
        counter++;
    }
 
    /* Write out the points in your favorite format */
 
}
 
void Normalise(p,r)
XYZ *p;
double r;
{
   double l;
 
   l = r / sqrt(p->x*p->x + p->y*p->y + p->z*p->z);
   p->x *= l;
   p->y *= l;
   p->z *= l;
}
 
double Distance(p1,p2)
XYZ p1,p2;
{
   XYZ p;
 
   p.x = p1.x - p2.x;
   p.y = p1.y - p2.y;
   p.z = p1.z - p2.z;
   return(sqrt(p.x*p.x + p.y*p.y + p.z*p.z));
}

● I've been using the wxWidgets 2.8 branch and Code::Blocks revision 6135
● I first installed XCode on my MacOS 10.6 (xcode probably sets up the developer tools you need, but I'm not sure)
● take care of the dynamic libraries and their locations
● some paths and files need to be copied to the bundle location which is not described anywhere (untill now)

Compiling and configuring
There wasn't really something special while compiling Code::Blocks, the only thing you should know, is that you run "./bootstrap" before you can configure it. (See the script below that I used).

Creating a bundle
When you've compiled Code::Blocks and wxWidgets using shared/dynamic libraries you need to tell the libraries and executables where they can find these. Normally they try to find the libraries in /usr/local/lib for example. This information is stored in the libraries and executables. Using "otool -L [file]" you can check which libraries are used by that file. With another util, called intall_name_tool you can change the paths to the dynamic libraries that a file uses. As you're creating an application bundle, it's wise to put all the necessary libraries in the bundle directory. If you don't know what an application bundle is, here is a quick summary. MacOS has a nice system to manage applications. When you open the Application directory in Finder you see all the applications with an icon. Though, under the hood, on the file system, these applications (or at least 99% of them), are named "Application.app", so with the ".app" extension. Finder removes these and creates a clickable application. Under this Application.app are a couple of other directories (Google for MacOS application bundle directories for more info). So, back to the libraries. It's wise to put the libraries you've compiled into the application bundle director and tell them about eachother so they will use the local libs instead of the system libs. See the script where we use install_name_tool for this. install_name_tool, works like this: install_name_tool [/path/to/library/which/is/used/now] [change/to/other/path] [change for this file]. When all paths have changed, the libraries and executables are set to go. When I did this I could run Code::Blocks but the plugins weren't installed which is something that must be done to use Code::Blocks (i.e. the project wizard is based on a plugin). For this I had to copy the [plugin].so files to the application bundle. At the bottom of the script you can see which files I had to copy as well. But here is a short list BTW: you need to bundle CodeBlocks into an application because else you can't focus or activate CodeBlocks, this is a wxWidgets thingie

● The icons can be found in C::B (svn dir)/src/src/resources/icons/*.icns and need to be moved to ${application_dir}/Contents/Resources
● The Info.plist file should be created, this can be found in the C::B build directory (so after compiling), named codeblocks.plist
● Make sure you use the --with-contribs=all flag when you compile Code::Blocks as it needs the plugins
● The plugin shared libraries should be copied to your application.app directory (see script for the location)
● Change the paths to the dynamic libraries that are used by your plugins (see the loop at the bottom of the script where we use install_name_tool)
● Make sure you configure with the CC/GCC etc.. flags set to "-arch 386": CFLAGS="-arch i386" CXXFLAGS="-arch i386" CPPFLAGS="-arch i386" LDFLAGS="-arch i386" OBJCFLAGS="-arch i386" OBJCXXFLAGS="-arch i386"

The script to create a CodeBlocks application on Mac form source
This script downloads the latest SVN version of Code::Blocks, the 2.8 branch of wxWidgets, creates some directories, configures wxWidgets/Code::Blocks and creates the CodeBlocks.app application bundle. The directories that are created:

● ./app: here you'll find your CodeBlocks.app
● ./codeblocks_svn
● ./wxwidgets_svn

The script will ask you a couple of questions, answer them by entering only a 'y' and make sure that you at least configured and compiled wxWidgets and C::B using the script at least once, before you answer something different than 'y'.

I hope this will help you to build a custom CodeBlocks application for Mac!

#!/bin/sh
#set -x
root_dir=${PWD}
 
if [ -d wxwidgets_svn ]
then
    read -p "Remove wxWidgets 2.8 directory to start clean install? [y/n]: " continue
    if test "${continue}" == "y" ;    then
        rm -r wxwidgets_svn
        mkdir wxwidgets_svn
    fi
else
    mkdir wxwidgets_svn
fi
 
if [ -d codeblocks_svn ]
then
    read -p "Remove CodeBlocks directory to start clean install? [y/n]: " continue
        if test "${continue}" == "y";  then
                rm -r codeblocks_svn
                mkdir codeblocks_svn
        fi
else
    mkdir codeblocks_svn
fi 
 
read -p "Download CodeBlocks from svn? [y/n]: " continue
if test "${continue}" == "y"; then
    cd codeblocks_svn
    svn co http://svn.berlios.de/svnroot/repos/codeblocks/trunk .
    cd ..
fi
 
read -p "Download wxWidgets 2.8 from svn? [y/n]: " continue
if test "${continue}" == "y"; then
    cd wxwidgets_svn
    svn co http://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_8_BRANCH .
fi
 
 
#------------------------- wxWidgets ---------------------------------------
read -p "Configure wxWidgets 2.8? [y/n]: " continue
if test "${continue}" == "y"; then
    if [ ! -d ${root_dir}/wxwidgets_svn ]; then
        echo "No wxWidgets directory found"
        exit
    fi
 
    cd ${root_dir}/wxwidgets_svn
    if [ -d build_custom ]; then
        rm -r build_custom
    fi
 
    mkdir build_custom
    cd build_custom
    ./../configure --enable-shared \
     --enable-monolithic \
     --enable-unicode \
     --with-png=builtin \
     --with-jpeg=builtin \
     --with-tiff=builtin \
     --with-expat=builtin/configure \
     --enable-shared \
     --enable-monolithic \
     --enable-unicode \
     --with-mac \
     --with-expat=builtin \
     CFLAGS="-arch i386" CXXFLAGS="-arch i386" CPPFLAGS="-arch i386" \
     LDFLAGS="-arch i386" OBJCFLAGS="-arch i386" OBJCXXFLAGS="-arch i386"
fi
 
read -p "Compile wxWidgets 2.8 [y/n]: " continue
if test "${continue}" == "y"; then
    cd ${root_dir}/wxwidgets_svn/build_custom
    make
fi
 
read -p "Bootstrap Code::Blocks [y/n]: " continue
if test "${continue}" == "y"; then
    cd ${root_dir}/codeblocks_svn
    ./bootstrap
fi
 
read -p "Configure Code::Blocks [y/n]: " continue
if test "${continue}" == "y"; then
    if [ ! -d ${root_dir}/codeblocks_svn ]; then
        echo "No CodeBlocks directory found"
        exit
    fi
 
    cd ${root_dir}/codeblocks_svn
 
    if [ -d custom_build ]; then
        rm -r custom_build
    fi
 
    mkdir custom_build
    cd custom_build
    ./../configure \
        --prefix=${root_dir}/codeblocks_svn/custom_build/ \
        --with-wxdir=./../../wxwidgets28_from_svn/custom_build/ \
        CFLAGS="-arch i386" CXXFLAGS="-arch i386" \
        CPPFLAGS="-arch i386" LDFLAGS="-arch i386" \
        OBJCFLAGS="-arch i386" \
        OBJCXXFLAGS="-arch i386" \
        --with-contrib-plugins=all \
        --enable-static \
        --enable-debug \
        --with-macosx \
        --with-wxdir=${root_dir}/wxwidgets_svn/build_custom/ \
        --with-wx-config=${root_dir}/wxwidgets_svn/build_custom/wx-config \
        --with-wx-prefix=${root_dir}/wxwidgets_svn/build_custom/ 
fi
 
read -p "Compile and make Code::Blocks [y/n]: " continue
if test "${continue}" == "y"; then
    cd ${root_dir}/codeblocks_svn/custom_build
    make
fi
 
read -p "Create CodeBlocks.app bundle? [y/n]: " continue
if test "${continue}" == "y"; then
    if [ -d ${root_dir}/app/CodeBlocks.app ]; then
        read -p "An Codeblocks.app bundle already exists, remove first? [y/n]: " continue
        if test "${continue}" == "y"; then
            rm -r ${root_dir}/app/CodeBlocks.app
        fi
    fi
 
    app_dir=${root_dir}/app/CodeBlocks.app
    cb_dir=${root_dir}/codeblocks_svn
    wx_dir=${root_dir}/wxwidgets_svn
 
    mkdir -p ${app_dir}/Contents/MacOS
    mkdir -p ${app_dir}/Contents/Resources/share/codeblocks
    cp ${cb_dir}/custom_build/codeblocks.plist ${app_dir}/Contents/Info.plist
    cp ${cb_dir}/src/src/resources/icons/*.icns ${app_dir}/Contents/Resources/
    cp -r ${cb_dir}/custom_build/share/codeblocks/* ${app_dir}/Contents/Resources/share/codeblocks/
    cp ${cb_dir}/custom_build/bin/codeblocks ${app_dir}/Contents/MacOS/CodeBlocks
    cp ${cb_dir}/custom_build/lib/libcodeblocks.0.dylib ${app_dir}/Contents/MacOS/
    cp ${cb_dir}/custom_build/lib/libwxsmithlib.0.dylib ${app_dir}/Contents/MacOS/
    cp ${wx_dir}/build_custom/lib/libwx_macu-2.8.0.dylib ${app_dir}/Contents/MacOS/
    chmod 777 ${app_dir}/Contents/MacOS/CodeBlocks  
fi
 
read -p "Change dynamic lib paths? [y/n]: " continue
if test "${continue}" == "y"; then
 
    # copy the plugins (original version)
    cd ${root_dir}/codeblocks_svn/custom_build/src/plugins
    mkdir -p ${root_dir}/app/CodeBlocks.app/Contents/Resources/share/codeblocks/plugins/
    for dir in `find -type d . -mindepth 1 -maxdepth 1`; do
        name=${dir##*/}
        plugin_libs=${root_dir}/codeblocks_svn/custom_build/src/plugins/${name}/.libs/
        for plugin_lib in ${plugin_libs}*.so; do
                if [ -f ${plugin_lib} ]; then    
                    cp ${plugin_lib} ${root_dir}/app/CodeBlocks.app/Contents/Resources/share/codeblocks/
                fi
        done
    done
 
    # copy the other plugins (which one do I need to choose)
    #cb_plugin_dir=${root_dir}/codeblocks_svn/custom_build/lib/codeblocks/plugins
    #for dir in ${cb_plugin_dir}/*.so; do
    # cp ${dir} ${root_dir}/app/CodeBlocks.app/Contents/Resources/share/codeblocks/
    #done
    for dir in `find --type d ${root_dir}/codeblocks_svn/custom_build/src/plugins/contrib -mindepth 1 -maxdepth 1`; do
            name=${dir##*/}
            libdir=${dir}/.libs
            if [ -d ${libdir} ]; then
                so_file=$(ls ${libdir}/*.so)
                    #if [ -f ${so_file} ]; then
                        #echo ${so_file}
                        #cp ${so_file} ${root_dir}/app/CodeBlocks.app/Contents/Resources/share/codeblocks/
                    #fi
                #echo ${libdir}
            fi
            #plugin=${root_dir}/codeblocks_svn/custom_build/src/plugins/contrib/${name}/.libs/lib${name}.so
        # if [ -f ${plugin} ]; then
            #        cp ${plugin} ${root_dir}/app/CodeBlocks.app/Contents/Resources/share/codeblocks/
            #fi
    done
    #cp /Users/diederickhuijbers/Documents/programming/_tests/cb1/codeblocks_svn/custom_build/src/plugins/compilergcc/.libs/libcompiler.so ${root_dir}/app/CodeBlocks.app/Contents/Resources/share/codeblocks/ 
 
 
    cd ${root_dir}/app/CodeBlocks.app/Contents
    install_name_tool -id @executable_path/libcodeblocks.0.dylib MacOS/libcodeblocks.0.dylib
    install_name_tool -id @executable_path/libwxsmith.0.dylib MacOS/libwxsmithlib.0.dylib
 
    install_name_tool -change ${root_dir}/codeblocks_svn/custom_build/lib/libcodeblocks.0.dylib @executable_path/libcodeblocks.0.dylib MacOS/CodeBlocks    
    install_name_tool -change ${root_dir}/codeblocks_svn/custom_build//lib/libcodeblocks.0.dylib @executable_path/libcodeblocks.0.dylib MacOS/CodeBlocks
    install_name_tool -change /usr/local/lib/libcodeblocks.0.dylib @executable_path/libcodeblocks.0.dylib MacOS/libwxsmithlib.0.dylib
    install_name_tool -change /usr/local/lib/libwx_macu-2.8.0.dylib @executable_path/libwx_macu-2.8.0.dylib MacOS/CodeBlocks
    install_name_tool -change /usr/local/lib/libwx_macu-2.8.0.dylib @executable_path/libwx_macu-2.8.0.dylib MacOS/libcodeblocks.0.dylib 
    install_name_tool -change /usr/local/lib/libwx_macu-2.8.0.dylib @executable_path/libwx_macu-2.8.0.dylib MacOS/libwxsmithlib.0.dylib
 
    for so in Resources/share/codeblocks/*.so; do
        libcodeblocks=$(otool -L ${so} | grep libcodeblocks)
        libcodeblocks=${libcodeblocks%%(*}
        install_name_tool -change ${libcodeblocks} @executable_path/libcodeblocks.0.dylib ${so}
 
        libwxsmith=$(otool -L ${so} | grep libwxsmithlib)
        libwxsmith=${libwxsmith%%(*}
        if test "${libwxsmith}" != ""; then
            install_name_tool -change ${libwxsmith} @executable_path/libwxsmithlib.0.dylib ${so}
        fi
 
        libwx=$(otool -L ${so} | grep libwx_macu)
        libwx=${libwx%%(*}
        if test "${libwx}" != ""}; then
            install_name_tool -change ${libwx} @executable_path/libwx_macu-2.8.0.dylib ${so}
        fi
 
        #install_name_tool -change /usr/local/lib/libcodeblocks.0.dylib @executable_path/libcodeblocks.0.dylib ${so}
        #install_name_tool -change /usr/local/lib/libwxsmithlib.0.dylib @executable_path/libwxsmithlib.0.dylib ${so}
        #install_name_tool -change /usr/local/lib/libwx_macu-2.8.0.dylib @executable_path/libwx_macu-2.8.0.dylib ${so}
    done
fi

What you need to know about preloaders when you create a separate preloader.swf for your site.

I'll explain a couple of things which are important when you create a preloader for your Flash based website. First of all: use a separate preloader.swf, do not put your preloader code in your site.swf. When I talk about site.swf, I'm talking about your big fat 2MB Flash based website and the preloader.swf is your slim and shiny tiny 2KB preloader.

In your site.swf (pseude code)

The important part is the ADDED_TO_STAGE event listener. Put this in de constructor of your Document class. This event is fired when the preloader.swf loads in site.swf and adds it as a child.

import flash.display.StageAlign;
import flash.display.StageScaleMode;
package {
  public class Site extends MovieClip {
 
    public function Site():void {
        addEventListener(Event.ADDED_TO_STAGE, init);
    }
 
   private function init():void {
      //  create your children here!
        stage.scaleMode = StageScaleMode.NO_SCALE;
        stage.align = StageAlign.TOP_LEFT;
   }
 }
}

In your preloader.swf (pseudo code)

After you've loaded your site.swf, you can start the intro tweens etc..

When you need to call a function on the loaded swf use:

var myLoader:Loader = new Loader();
var myUrlReq:URLRequest = new URLRequest(”data.swf”);
myLoader.load(myUrlReq);
myLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, onLoaded);

...and the complete handler...

function onLoaded(event:Event):void {
    var Square:Class = event.target.applicationDomain.getDefinition(”Square”) as Class
    var mySquare:MovieClip = new Square() as MovieClip;
    addChild(mySquare);
}

import Blender 
from Blender.Object import *
from Blender import Window,Scene,Material
from math import *
import sys
 
scn = Scene.GetCurrent()
num_rows = 10
num_objects = 19
angle_per_obj = (pi * 2)/num_objects
radius = 10.4
angle = 0 
z = 0
 
for row in range(num_rows):
    angle += angle_per_obj/2
    for x in range(num_objects):
        print x
        Blender.Object.Duplicate()
        active = scn.objects.active
        x = cos(angle) * radius
        y = sin(angle) * radius
        active.LocX = x
        active.LocY = y  
        active.LocZ = z
        active.RotZ = angle + pi/2
        angle += angle_per_obj
    z+= 3

When defining a bounding box it's wise to use members variables like:

min_x  
min_y  
max_x  
max_y

and not variable like

x  
y  
width  
height

Why not?
Because using the min_x/max_x variant reduces the number of calculations you have to do for both collision detection and drawing; For example this is how we check the bounding box collision using the min_x variant:

return ((nX > min_x) && (nX < max_x) && (nY > min_y) && (nY < max_y));

where this is the x/y/width/height variant:

return ((tx > x) && (tx < x + width) && (ty > y) && (ty < y + height));

Do you see we need to accumulate a couple of things over there? Well these are just 2 calculations which are dont around 60 times per second when you've a framerate of 60 for each visual object you have.

Tim Olden showed us some pictures of his "light installation" (what's the name?) he showed at LowLands 2009.

Just as a reminder, this book, The Hidden Language of Computer Hardware and Software passed along; maybe or probably it's interesting to read.

Have a look at the screenshots for the important settigns I changed after doing File > Print ...

I'm working on lot's of projects at the moment which is why this blog hasn't been updated in a while. Though I haven't been doing nothing ;-). As you maybe know I'm building my house and we just finished the kitchen! Besides working on my house I'm working on the YouCube project which is due at 20 august when we go to LowLands 2009! Before we go to LowLands I want to finish a website for some clients. After these projects I will start working on my house again ;-) .. and hopefully I'm ready at the end of september when I can start working on some really nice projects I'm looking forwarrd to.

I've been working on some features for our companies (ApolloMedia) internally used Flash library. It now has some nice plugin system which is able to load assets files from different locations and initializes a website based on a XML file. All transisitions between the states in the site can be defined in the XML file. Using this "recursive state model" (as how I called it) we will be able to create flash websites in a flash ;-) To make these websites maintainable I've been working on a new module for our CMS which is able to administrate things like menu/menu-items, images, videos, carousels etc..

.. for this module I used tidy to format the XML.. so just as a reminder for myself:

// tidy rules!!
$a_config = array(
    'indent'       => true
    ,'input-xml'   => true
    ,'output-xml'  => true
    ,'wrap'        => 200
);
$o_tidy = new tidy;
$o_tidy->parseString($s_xml, $a_config, 'utf8');
$o_tidy->cleanRepair();
$s_xml = (string)$o_tidy

Glowies from roxlu on Vimeo.

Flocking with openFrameworks from roxlu on Vimeo.

Next thing I want to do is adding a force which follows a person when walking in front of the webcam. When you walk by you're followed by these sweet jellies!

BTW, the best results I found using a somewhat adjusted ofxBox2dSoftBody object; see www.openframeworks.info for a spring based soft body which seemed to work very well.

Rigid bodies

Demo (I only use T-Mobile as an example; I'm not (yet) hired by T-Mobile

gluLookAt(camX, camY, camZ, eyeX, eyeY, eyeZ, upX, upY, upZ)

camX/Y/Z: Position of the camera
eyeX/Y/Z: Camera looks at this position
upX/Y/Z: The up vector, mostly use: 0,1,0 (what's the top of the camera

Experimenting with Grass animation from roxlu on Vimeo.

While googling on Bullet I found these sites which seems interesting:

• http://www.rchoetzlein.com/art/index.htm

Video of an algoritm found on above site

water simulation from arturo on Vimeo.

This images show a couple of springs tied up. The squares have multiple springs connected so the stay in their 'square like' shape. This could be used to create jelly like surfaces.

As a reminder for myself these are some things I'm working on:

• Center of mass (visualisation)
• Angle between two vectors (visualisation)
• Steering behavior: separation
• Steering behavior: cohesion
• Steering behavior: alignment

Above you can see an example of grass which I created using Spring physics. It's a quick sketch using processing. When I've played around with enough visualization techniques I'll continue on my "Flickr Hunt" application.

Some interesting project I found while googling for natural algorithms is Carnival Aquarium. See carnival @ flickr

I can probably improve the results when I use infrared and a table like reatable with better lightning conditions. But, it would be very nice to use these marker on my iphone and the x/y/z sensor.... (this will be continued)

Stay tuned....

Another very interesting and funny project called BlockBlazers is presented. In this pervasive game you use Wii remotes to control a 2D platform game which is spread over two screens. The screens are positioned with their back against each other. When your game character runs to the left of the screen it pops up in the other screen and you've to run around the screen. See FourceLabs for more information about the creators of BlockBlazers.

Next to BlockBlazers you can try out LevelHead which is a augmented reality game. You control a cube with ARToolkit markers. Best way to explain this is to have a look at this video:

A picture of the installation at Cinekid Zoetermeer.

And if this wasnt enough, we have Globe4D. Globe4D is a project of Rick Companje, Nico van Dijk, Hanco Hogenbirk, Danica Mast and Dirk Jansen. Globe4D is an interactive, four-dimensional globe. It’s a projection of the Earth’s surface on a physical sphere. It shows the historical movement of the continents as its main feature, but it is also capable of displaying all kinds of other geographical data such as climate changes, plant growth, radiation, rainfall, forest fires, seasons, airplane routes, and more.

Rol Je Rot Rolstoel Race

And of course some pictures of our project:

I'll try to post on a two daily basis about internet, design, marketing, technology, science and my favorite Media Technology related topics.