I've always been curious to see if I could get a processing session going from Window's Command Prompt. This is the way I do Python programming, and I imagine there's a way to get it going for processing - I just don't know how.

It seems like a great way to open a big synchronized project in one go!

Also: is this the right forum, or should it go with Processing Implementations?

I posted this last night, but it seems to have disappeared. Mod's lot me know if you deleted this, and I wont worry about it!

So I'm working on an interesting project in the super collider to processing library.

However, I've run into a snag. I'm using the Synth.get feature to watch the amplitude of a Synth, and all I get back is a default value


SynthDef(\voice, { |outbus = 0, amp = 10, freq = 440, pan = 0|
        var data;
       amp = SinOsc.kr(20,1,20); // Amplitude.kr( SoundIn.ar(0)) * 10 ;          
        freq = Lag.kr(freq, 0.1);
        data = SinOsc.ar(freq, 0, amp);
        Out.ar(outbus, Pan2.ar(data, pan));
}).store;

here's the synth def.

and here's the processing code (prepare! - the relevant bit is at the very bottom ):


import supercollider.*;
import oscP5.*;
import netP5.*;

Synth synth;

Synth voice;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Timer

class Timer {
 
  int timedelt = 1;
  int time = 0;
 int  timeit(){
 
 
     this.time += this.timedelt ;
     return time;

 
 };

void reset(){time = 0;};

void printme(){print(time);};



}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Makes the circle

class Circle {
  float radius, delta;
  float xdelt;
  float ydelt;
  float x, y;
  float randomgrowth;
  Circle ( int radius, int delta ) {
    this.radius = radius;
    this.delta = delta;
     
    this.x = random(1000);
    this.y = random(1000);
    this.xdelt = random(40)- 20;
    this.ydelt = random(40) - 20;
    this.randomgrowth = random(400);
   
  }
 
  void draw() {
    fill(25,25,25,25);
    ellipse(this.x, this.y, this.radius, this.radius);
    fill(127,255,0,25);
    ellipse(this.x , this.y , this.radius / 2, this.radius / 2 + 10);
    synth.set("amp",   this.radius / 500);
    synth.set("freq", 80 + this.y / 10);
    synth.set("lfofreq", this.x / 10);
  }
 
  void update(){
    if(radius >= randomgrowth){
     // this.delta *= -1;
      this.radius = randomgrowth;
    }
   /* else if ( radius < 0 ) {
      this.delta *= -1;
      this.radius = 0;
    }
   */          
   if (this.x >= 1200 ) {
       this.x *= -1;
   }
    if (this.y >= 1200 ) {
       this.y *= -1;
   }
    this.radius += this.delta;
    this.x += this.xdelt;
    this.y += this.ydelt;
   
  }
 void kill(){                                 ///// Kills the Circle
   this.radius = 0;
   this.delta = 0;
  // synth.free();
   
   
 }
}

Circle circle;
Circle[] circlearray;
Timer timeguy;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////SQUARE  

class Square {
  float size, delta;
  float xdelt;
  float ydelt;
  float x, y;  
 

    Square ( int size ) {
    this.size = size;
    this.delta = delta;
     voice.get("amp",  this, "deltamod");  

    this.x = random(500);
    this.y = random(500);
    this.xdelt = random(40)- 20;
    this.ydelt = random(40) - 20;
 

   
  }
 

 

 
 
  void draw(){
   fill(25,25,25,25);
   rect(this.x , this.y, this.size  ,this.size );
   }
   
   
   void update(){
   
this.size += this.delta;
 if (this.size == 500){
   square.kill();
   for(int i = 0; i < 50; i++){
  circlearray[i].kill();
 }  
     
   }
   }
   
   
    void kill(){                                 ///// Kills the Square
   this.size = 0;
   this.delta = 0;
  // synth.free();
   
   
 }
   
   
   
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////// SETUP
 
 
}
Square square;

void setup(){
 
      // uses default sc server at 127.0.0.1:57110    
    // does NOT create synth!
    synth = new Synth("sine");
    voice = new Synth("voice");
   
    // set initial arguments
    synth.set("amp", 0.5);
    synth.set("freq", 80);
  //  voice.set("amp", 10);
    voice.set("freq", 0);
   
    // create synth
    synth.create();
    voice.create();
 
  size(1200,800);
  timeguy = new Timer();
  circle = new Circle(40,2);
  square = new Square(40);
  int[] foo = new int[10];
  circlearray =  new Circle[100];
  for( int i = 0; i < 100; i++){
    circlearray[i] = new Circle(40,2);
   
     }
     
  }
 
//////////////////////////////////////////////////////////////////////////////IMPLEMENT
void draw(){
  timeguy.timeit();
  timeguy.printme();
  circle.update();
  square.update();
  background(255,0,0);
  circle.draw();
  square.draw();
  voice.get("amp", this, "show");
 
 
 
  for( int i = 0; i < 100; i++){
    circlearray[i].update();
    circlearray[i].draw();
   
  }
 
   
    if(timeguy.time  == 1200){
      for( int i = 0; i < 100; i++){
    circlearray[i].kill();
   
      }
     
     };    
     }
/////


void mousePressed ()
{
  voice.get("amp", this, "show");
}

void show (int nodeID, String arg, float value)
{
  println("amp " + value);
  square.delta = value;
  if (square.size > 100){
    square.kill();}
}

One idea I have entertained is that the Synthdef only spits out default values until you tell it to do something. I'm not sure how I'll make it do something "fake" so that I can simply read amplitudes from the microphone into processing.

Does anyone have any ideas?

The super collider guys have insinuated to me that I simply can't use a Synthdef in this way. Has anyone here found another way to get live amplitude values into processing? this is kind of maddening since I've been touting processing's superiority to Jitter/GEM lately.

Ok! I thought a project would be a great way to "get into" processing a little further than I had before.


So my goal this time around is to get processing to generate a finite number of circles, each with it's own identity. The circles should be generated slowly over the course of say 30 seconds, and grow into place instead of appear. Once grown the circles should move about freely until I decide to kill them with a mouse click or something. The ultimate goal is for (using some kind audio library) a singer to be able to kill them off using amplitude / pitch triggers (this part I can manage pretty well in an outside audio application).

So here's how far I've gotten:

void setup(){

size(1200,650);
background(20);
frameRate = 30;

}

void draw(){

for(int i=0; i<2; i++){
fill(0,201,87);
ellipse(random(1200), random(650), 55, 55);
}

}

This generates an infinite number of circles without giving them any kind of individual identity. If I wanted animate any of the generated circles, or destroy them I'm not sure how I'd go about doing it. Now I suspect the answer to my question lies in making a class, but I'm not sure how you'd generate objects and still let them have a  unique identity.

Any advice for the newbie?

Greeting all! I'm a processing newbie so please go easy.

I've been doing a project with the super collider library to learn some processing.
For a basic test of concept I've having rectangles spawn on click, but I'm stumped
as to how they should "stay". I imagine I insert a "delay" command somewhere,
though I would prefer it if there was just a static maximum number of rectangles
available.

Here's my code so far:

// ojective 1: make new synthes and things per click.


import supercollider.*;
import oscP5.*;
import netP5.*;

Synth synth;

void setup ()
{
    size(800, 800);

    // uses default sc server at 127.0.0.1:57110   
    // does NOT create synth!
    synth = new Synth("sine");
   
    // set initial arguments
    synth.set("amp", 0.5);
    synth.set("freq", 80);
   
}

void draw ()
{
    background(0);
}

void mousePressed() {
 float r = random ( 0, 800);
 float s = random ( 0, 800);
 float t = random ( 0, 800);
 float u = random ( 0, 800);
  float v = random ( 0, 10000);
 
rect(r,s ,t , u);
 

synth.create();
synth.set("freq", 40 + v);
}

at least it makes noise!