Hi forum, I'm trying to run on my computer this code, taken from

Hi list. I'm working with my ipad and processing. the basic idea is to connect several ipad via TUIO to a processing sketch.

I started with the particle example of toxi libs and I connecected the mouse position to TUIO variables. But sometimes I got this error " ConcurrentModificationException" that make me crazy.

In other words I'm trying in those firsts steps to merge the the particle example of toxi with the TUIO demo example.

On Ipad is running TUIOpad 1.0

I have this error with Ipad and TUIO simulator as well.

 Help me please!!

here the code

1. 
   /**
    * <p>Usage: Click and drag mouse to attract particles</p>
    */
   
   /*
    * Copyright (c) 2010 Karsten Schmidt
    *
    *some modifications by pixelorchestra
    *
    *http://creativecommons.org/licenses/LGPL/2.1/
    *
    */
    
   import processing.opengl.*;
   
   
   import toxi.geom.*;
   import toxi.physics2d.*;
   import toxi.physics2d.behaviors.*;
   
   int NUM_PARTICLES = 500;
   
   VerletPhysics2D physics;
   AttractionBehavior mouseAttractor;
   
   Vec2D mousePos;
   
   void setup() {
     size(680, 382, OPENGL);
     // setup physics with 10% drag
     physics = new VerletPhysics2D();
     physics.setDrag(0.05f);
     physics.setWorldBounds(new Rect(0, 0, width, height));
     // the NEW way to add gravity to the simulation, using behaviors
     //  physics.addBehavior(new GravityBehavior(new Vec2D(0, 0)));
    
    
    // init the TUIO protocol
     setupTUIO();
    
    
   }
   
   void addParticle() {
     VerletParticle2D p = new VerletParticle2D(Vec2D.randomVector().scale(5).addSelf(width / 2, height/2));
     physics.addParticle(p);
     // add a negative attraction force field around the new particle
     physics.addBehavior(new AttractionBehavior(p, 20, -1.2f, 0.01f));
   }
   
   void draw() {
     background(0, 0, 0);
     noStroke();
     fill(255);
     if (physics.particles.size() < NUM_PARTICLES) {
       addParticle();
     }
     physics.update();   // <----- HERE I GOT THE ERROR
     stroke(255);
     for (VerletParticle2D p : physics.particles) {
        ellipse(p.x, p.y, 10, 10);
       //point(p.x, p.y);
     }
    
     drawTUIO(); // call the TUIO function
   }
   
   // this is just to test with mouse
   void mousePressed() {
     initDrag(mouseX, mouseY);
   }
   
   void mouseDragged() {
     dragging(mouseX, mouseY);
   }
   
   void mouseReleased() {
     removeDrag();
   }
   
   void initDrag(int posX, int posY) {
   
     mousePos = new Vec2D(posX, posY);
     // create a new positive attraction force field around the mouse position (radius=250px)
     mouseAttractor = new AttractionBehavior(mousePos, 250, 0.9f);
     physics.addBehavior(mouseAttractor);
   }
   
   void dragging(int posX, int posY) {
     // update mouse attraction focal point
     mousePos.set(posX, posY);
   }
   
   void removeDrag() {
     // remove the mouse attraction when button has been released
     physics.removeBehavior(mouseAttractor);
   }
2. // we need to import the TUIO library
   // and declare a TuioProcessing client variable
   
   
   import TUIO.*;
   TuioProcessing tuioClient;
   
   // these are some helper variables which are used
   // to create scalable graphical feedback
   float cursor_size = 15;
   float object_size = 60;
   float table_size = 760;
   float scale_factor = 1;
   PFont font;
   
   
   
   void setupTUIO(){
   
     hint(ENABLE_NATIVE_FONTS);
     font = createFont("Arial", 18);
     scale_factor = height/table_size;
    
     // we create an instance of the TuioProcessing client
     // since we add "this" class as an argument the TuioProcessing class expects
     // an implementation of the TUIO callback methods (see below)
     tuioClient  = new TuioProcessing(this);
   
   }
   
   
   void drawTUIO()
   {
     textFont(font,18*scale_factor);
     float obj_size = object_size*scale_factor;
     float cur_size = cursor_size*scale_factor;
     
     Vector tuioObjectList = tuioClient.getTuioObjects();
     for (int i=0;i<tuioObjectList.size();i++) {
        TuioObject tobj = (TuioObject)tuioObjectList.elementAt(i);
        stroke(0);
        fill(0);
        pushMatrix();
        translate(tobj.getScreenX(width),tobj.getScreenY(height));
        rotate(tobj.getAngle());
        rect(-obj_size/2,-obj_size/2,obj_size,obj_size);
        popMatrix();
        fill(255);
        text(""+tobj.getSymbolID(), tobj.getScreenX(width), tobj.getScreenY(height));
      }
     
      Vector tuioCursorList = tuioClient.getTuioCursors();
      for (int i=0;i<tuioCursorList.size();i++) {
         TuioCursor tcur = (TuioCursor)tuioCursorList.elementAt(i);
         Vector pointList = tcur.getPath();
        
         if (pointList.size()>0) {
           stroke(0,0,255);
           TuioPoint start_point = (TuioPoint)pointList.firstElement();;
           for (int j=0;j<pointList.size();j++) {
              TuioPoint end_point = (TuioPoint)pointList.elementAt(j);
              line(start_point.getScreenX(width),start_point.getScreenY(height),end_point.getScreenX(width),end_point.getScreenY(height));
              start_point = end_point;
           }
          
           stroke(192,192,192);
           fill(192,192,192);
           ellipse( tcur.getScreenX(width), tcur.getScreenY(height),cur_size,cur_size);
           fill(0);
           text(""+ tcur.getCursorID(),  tcur.getScreenX(width)-5,  tcur.getScreenY(height)+5);
         }
      }
     
   }
   
   
   // these callback methods are called whenever a TUIO event occurs
   
   // called when an object is added to the scene
   void addTuioObject(TuioObject tobj) {
     println("add object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle());
   }
   
   // called when an object is removed from the scene
   void removeTuioObject(TuioObject tobj) {
     println("remove object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+")");
   }
   
   // called when an object is moved
   void updateTuioObject (TuioObject tobj) {
     println("update object "+tobj.getSymbolID()+" ("+tobj.getSessionID()+") "+tobj.getX()+" "+tobj.getY()+" "+tobj.getAngle()
             +" "+tobj.getMotionSpeed()+" "+tobj.getRotationSpeed()+" "+tobj.getMotionAccel()+" "+tobj.getRotationAccel());
   }
   
   // called when a cursor is added to the scene
   void addTuioCursor(TuioCursor tcur) {
    
     initDrag(tcur.getScreenX(width), tcur.getScreenY(height) );  // INIT DRAG
   
    
     println("add cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY());
   }
   
   // called when a cursor is moved
   void updateTuioCursor (TuioCursor tcur) {
     println("update cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+ ") " +tcur.getX()+" "+tcur.getY()
             +" "+tcur.getMotionSpeed()+" "+tcur.getMotionAccel());
             
       dragging(tcur.getScreenX(width), tcur.getScreenY(height) );
   }
   
   // called when a cursor is removed from the scene
   void removeTuioCursor(TuioCursor tcur) {
     removeDrag();
     println("remove cursor "+tcur.getCursorID()+" ("+tcur.getSessionID()+")");
   }
   
   // called after each message bundle
   // representing the end of an image frame
   void refresh(TuioTime bundleTime) {
     redraw();
   }
   
   

hello list!

I'm developing a building size installation and now i have a little big problem. Usually i'm using matrox dual head connected to my mac book pro to split my 2048*768 external desktop in to signals for to separate 1024*768 beamers. This matrox works smooth without problems. Now this building is taller than wide and my screen should be 1024*1536 (two 1024*768 placed in vertical). That's means I have to put my projectors in vertical stack.

There is a external box (similar to matrox dual) that split the image for me???

I'm considering the option to buy a new windows based pc to do that, is there  a commercial nvida card works for my needs???

any help will be appreciated

Starting from this wiki and jeff_g suggestion I did a particle system rendered with VBO and using the terrific traer library.
I'm really happy because is very fast: 50k particle at 60fps.

here the code:

1. import processing.opengl.*;
   import javax.media.opengl.*;
   import java.nio.FloatBuffer ;
   import javax.media.opengl.glu.*;
   import com.sun.opengl.util.*;
   
   
   import traer.physics.*;
   
   
   FloatBuffer fb;   // float buffer for x,y particle position
   FloatBuffer fbColor; // float buffer for RGBA color
   FloatBuffer fbLines; // float buffer for RGBA color
   
   
   
   
   final int NUM_PARTICLES=50000;  // tons of particles"
   
   Particle[] p;    // array containing all particles
   Particle mouse;  // magnet
   
   ParticleSystem physics;
   
   void setup()
   {
     size( 800, 600,OPENGL );
     frameRate( 60 );
     hint(ENABLE_OPENGL_4X_SMOOTH);
    
     noStroke();
     noCursor();
       noFill();
      
     physics = new ParticleSystem();
    
     mouse = physics.makeParticle();
     mouse.makeFixed();
   
   
     
     physics.setIntegrator( ParticleSystem.MODIFIED_EULER );
     physics.setDrag( 0.01 );
   
     p=new Particle[NUM_PARTICLES]; // init the p array
   
   
   
     for(int i=0; i<p.length; i++) {
      
       p[i]=physics.makeParticle( 1.0, random( 0, width ), random( 0, height ), 0 ); // make particle
       physics.makeAttraction( mouse,  p[i], 10000, 100 );                            // make attraction
     }
   
   
   
   
     fb = BufferUtil.newFloatBuffer(NUM_PARTICLES*2);          // init pos float buffer X Y
     fbColor = BufferUtil.newFloatBuffer(NUM_PARTICLES * 4);    // init color float buffer R G B A
       fbLines = BufferUtil.newFloatBuffer(NUM_PARTICLES * 4);    // init lines float buffer x1, y1, x2, y2
   
   
   
     PGraphicsOpenGL pgl = (PGraphicsOpenGL) g;         
     GL gl = pgl.beginGL();
   
     for (int i = 0; i < NUM_PARTICLES; i++) {
   
       //  r,g,b,a
       fbColor.put(1);
       fbColor.put(1);
       fbColor.put(1);
       fbColor.put(.4);
     }
    
     fbColor.rewind();
   
   
     gl.glEnableClientState(GL.GL_VERTEX_ARRAY);        // particles
     gl.glVertexPointer(2, GL.GL_FLOAT, 0, fb);
   
   
     gl.glEnableClientState(GL.GL_COLOR_ARRAY);          //  particles' color
     gl.glColorPointer(4, GL.GL_FLOAT, 0, fbColor);
   
     gl.glEnableClientState(GL.GL_VERTEX_ARRAY);        // line
     gl.glVertexPointer(2, GL.GL_FLOAT, 0, fbLines);
    
     gl.glPointSize(1);                                // particle size
     pgl.endGL();
    
    
    
   
    
    
    
   }
   
   
   
   void draw()
   {
     frame.setTitle(str(frameRate));
     mouse.position().set( mouseX, mouseY, 0 );      // set the magnet position
   
   
     physics.tick();                            // advance physic simulation
   
     background( 0 );
   
     stroke( 255 );
     ellipse( mouse.position().x(), mouse.position().y(), 35, 35 );    // draw the magnet
   
   
   
   
   int lineCounter=0;
     for(int i=0; i<p.length; i++) {
       fb.put(p[i].position().x());          // put the x,y particle position into the buffer
       fb.put(p[i].position().y());
       
         if(i!=0) {
               float d=dist(p[i].position().x(), p[i].position().y(),p[i-1].position().x(), p[i-1].position().y());
               if(d<100) { 
                 fbLines.put(p[i].position().x());       
                 fbLines.put(p[i].position().y());
                  fbLines.put(p[i-1].position().x());          // put the x1, y1, x2, y2 particles position into the line buffer
                 fbLines.put(p[i-1].position().y());
                 lineCounter++;                                 
               }
         }
       handleBoundaryCollisions( p[i] );    // perform the collision
     }
   
     fb.rewind(); 
       fbLines.rewind(); 
    
     PGraphicsOpenGL pgl = (PGraphicsOpenGL) g; 
     GL gl = pgl.beginGL();
                                              
     gl.glVertexPointer(2,GL.GL_FLOAT,0,fb);                // draw the particles
     gl.glDrawArrays(GL.GL_POINTS,0,NUM_PARTICLES);
    
    
     gl.glVertexPointer(2,GL.GL_FLOAT,0,fbLines);                // draw the lines
     gl.glDrawArrays(GL.GL_LINES,0,lineCounter);                  // end when lineCounter in reached
    
    
   
     pgl.endGL();
   
   }
   
   
   
   
   
   // really basic collision strategy:
   // sides of the window are walls
   // if it hits a wall pull it outside the wall and flip the direction of the velocity
   // the collisions aren't perfect so we take them down a notch too
   void handleBoundaryCollisions( Particle p )
   {
     if ( p.position().x() < 0 || p.position().x() > width )
       p.velocity().set( -0.999*p.velocity().x(), p.velocity().y(), 0 );
     if ( p.position().y() < 0 || p.position().y() > height )
       p.velocity().set( p.velocity().x(), -0.999*p.velocity().y(), 0 );
     p.position().set( constrain( p.position().x(), 0, width ), constrain( p.position().y(), 0, height ), 0 );
   }
   
   

now I have only one colorBuffer to color particles and lines booth....

How I can draw particles and lines whit different colors???

Sorry for non italian readers but the workshop will be in Rome only for italian speakers ...

Laboratorio sulle tematiche legate all’interaction-design. Organizzato da Il Pagliaio con Quiet ensemble e Pixelorchestra. Obiettivo del corso è fornire una panoramica esaustiva sulle potenzialità di 2 delle realtà più attive nel panorama dello sviluppo di contenuti interattivi. I partecipanti al gruppo produrranno un software funzionante con la realizzazione di un’interfaccia fisica progettata per l’occasione.

www.pixelorchestra.com

hello list,
      i'm pretty new to opengl programming and i have a billion dollar question. I have a particle system running and i draw every particle with opengl

1.    gl.glBegin(GL.GL_POINTS);        
         gl.glColor4f(1,1, 1,.5);
         gl.glVertex2f(p[i].position().x(), p[i].position().y());
2.       gl.glEnd();

were p[i].position().x(), p[i].position().y() are the x,y position of my particles.

I'm drawing my particles in white over black background.

now I'd like to have a fancy effect in my sketch putting on top  in "multiply" blending mode a texured quad.

1. maskTexture.bind();
     maskTexture.enable();
     gl.glBegin(GL.GL_QUADS);
     gl.glNormal3f( 0.0f, 0.0f, 1.0f);
     gl.glTexCoord2f(0, 0);
     gl.glVertex2f(0, 0);
     gl.glTexCoord2f(1, 0);
     gl.glVertex2f(width, 0);
     gl.glTexCoord2f(1, 1);
     gl.glVertex2f(width, height);
     gl.glTexCoord2f(0, 1);
     gl.glVertex2f(0,height);
     gl.glEnd(); 
   
     maskTexture.disable();
   

were maskTexture is a jpg with a gradient color.
The effect is done by   gl.glBlendFunc(GL.GL_ZERO, GL.GL_SRC_COLOR);

the result is:


i like the result BUT THE PERFORMANCE IS SIGNIFICANTLY REDUCED. I know every cycle cpu have to calculate the blending on all screen, but

there is a way to speed up the rendering?

thanks a lot.

hello, I'm working on the bouncing ball example dowloaded from traer website.

Once i've created my "magnet" particle and created the attraction between the magnet and the all others particles, i'd like to change its strength()  dynamically.

When I press the mouse button the attraction force is 10000 otherwise is 0. The code is below

1. void mousePressed() {
     attraction=10000;
    mouse.setStrength( attraction );
   
     }
    
     void mouseReleased() {
         attraction=0;
           mouse.setStrength( attraction );
     }

  Processing said that the function setStrength doesn't exist!!!!!


any suggestion????


following the complete code with the error line commented...

Thanks a lot.....

1. ////******* modified from bouncing balls example @ ~traer/physics *******////
   //// http://pixelorchestra.com //// 
   
   
   import processing.opengl.*;
   
   import traer.physics.*;
   
   Particle mouse;
   
   ParticleSystem physics;
   Particle[] p;
   
   
   int numParticle=10000;
   
   float attraction=10000;
   
   void setup()
   {
     size( 800, 800, OPENGL);
     // hint(ENABLE_OPENGL_4X_SMOOTH);
     hint(DISABLE_DEPTH_TEST);
     frameRate( 60 );
     smooth();
     ellipseMode( CENTER );
     noStroke();
     noCursor();
     strokeWeight(2);
   
     physics = new ParticleSystem(0,0);
     mouse = physics.makeParticle();
     mouse.makeFixed();
   
     p= new Particle[numParticle];
   
     for (int i=0; i<p.length;i++) {
   
       p[i]=physics.makeParticle( 1.0, random( width/2-100, width/2+100 ), random(  height/2-100,height/2+100 ), 0 );
       p[i].velocity().add (random(-1,1), random(-1,1), 0 ); // add some random moviment
       physics.makeAttraction( mouse, p[i],attraction, 100 ); // make attraction between mouse and particles
     }
   }
   
   
   void draw()
   {
    
       physics.tick(); // advance particle simulation
      
     mouse.position().set( mouseX, mouseY, 0 );  // move the magnet
   
     for (int i=0; i<p.length;i++) {        //
       handleBoundaryCollisions( p[i] );
     }
   
   
   
   
     background( 0 );
    
     // draw the magnet
     stroke( 255 );
     noFill();
     ellipse( mouse.position().x(), mouse.position().y(), 35, 35 );
   
   
   
     // draw the lines
     stroke( 255,70 );
       // for all particles
     for (int i=0; i<p.length;i++) {
       // if not the first particle
       if(i!=0) {
         // calculate the distance between the particles
         float d=dist(p[i].position().x(), p[i].position().y(),p[i-1].position().x(), p[i-1].position().y());
         // if the distance is less than 200
         if(d<200)
         // draw a line
           line(p[i].position().x(), p[i].position().y(),p[i-1].position().x(), p[i-1].position().y());
       }
     }
   }
   
   // really basic collision strategy:
   // sides of the window are walls
   // if it hits a wall pull it outside the wall and flip the direction of the velocity
   // the collisions aren't perfect so we take them down a notch too
   void handleBoundaryCollisions( Particle p )
   {
   
     if ( p.position().x() < 0 || p.position().x() > width )
       p.velocity().set( -0.9*p.velocity().x(), p.velocity().y(), 0 );
     if ( p.position().y() < 0 || p.position().y() > height )
       p.velocity().set( p.velocity().x(), -0.9*p.velocity().y(), 0 );
     p.position().set( constrain( p.position().x(), 0, width ), constrain( p.position().y(), 0, height ), 0 );
   }
   
   void mousePressed() {
     attraction=10000;
    // mouse.setStrength( attraction );
   
     }
    
     void mouseReleased() {
         attraction=0;
      //     mouse.setStrength( attraction );
     }