Hello,

I am going for a kind of flying-through-space effect with random-colored lines, and I've basically got it, but if I set the "timer" variable too high, I get like an overload of lines and a bunch of random lines intersecting the origin are randomly drawn.  The structure of the code is this; there is a class called "littlelight" which are the individual lines erupting from the origin.  That class is called every frame--and every frame a new "littlelight" is generated by "ps" which is an instance of the ParticleSystem class.  The ParticleSystem class removes "littlelight"'s from the ArrayList when their "timer" has run out.  The "timer" is set to run to zero about when that "littlelight" is entirely off-screen; so, once a "littlelight" leaves the screen area, it dies.  However, I really have no idea where this overload behavior is coming from.

This uses toxic libs btw.  The code is set now to overload as I have described above.  If you go down to where the "timer" variable is set, you will see I have commented code that will work.

This code is based on this example from the Processing website.  http://processing.org/learning/topics/simpleparticlesystem.html

Thanks

import toxi.geom.*;
ParticleSystem ps;

void setup ()
{
  size(1280, 720, P3D);
  frameRate(30);
  translate(width/2, height/2);
  ps = new ParticleSystem(1, new Vec3D(0, 0, 0));
  //smooth();
}

void draw() {
  translate(width/2, height/2);
  background(0);
  ps.run();
  ps.addlittlelight(0, 0);
  noStroke();
  translate(-width/2, -height/2);
}

class ParticleSystem {

  //GLOBAL VARIABLES
  ArrayList particles;   // An arraylist for all the particles
  Vec3D origin;          // An origin point for where particles are born

    //CONSTRUCTOR
  ParticleSystem(int num, Vec3D v) {
    particles = new ArrayList();     // Initialize the arraylist
    origin = v;                      // Store the origin point
    // Add "num" amount of particles to the arraylist
    //for (int i = 0; i < num; i++) {
      //particles.add(new littlelight(origin));
    //}
  }

  //FUNCTIONS
  void run() {
    for (int i = particles.size() - 1; i>=0; i--) {
      littlelight p = (littlelight) particles.get(i);
      //p.run();
      if (p.dead()) {
        particles.remove(i);
      }
      else p.run();
    }
  }

  /*
  void addlittlelight() {
   particles.add(new littlelight(origin));
   }
   */

  void addlittlelight(float x, float y) {
    particles.add(new littlelight(new Vec3D(x, y, 0)));
  }

  /*
  void addlittlelight(littlelight p) {
   particles.add(p);
   }
   */

  boolean dead() {
    if (particles.isEmpty()) {
      return true;
    }
    else
    {
      return false;
    }
  }
}

class littlelight {

  //GLOBAL VARIABLES
  Vec3D loc;
  Vec3D loc2;
  Vec3D vel = new Vec3D(random(-1, 1), random(-1, 1), random(0.9, 0.99));
  Vec3D acc;
  float r;
  float timer;
  float colorr = random(0, 255);
  float colorg = random(0, 255);
  float colorb = random(0, 255);
  float len = 100;

  //CONSTRUCTOR
  littlelight(Vec3D l) {
    //vel = new Vec3D(random(-1, 1), random(-1, 1), random(0.9, 0.99));
    acc = vel.copy();
    acc.normalizeTo(1);
    loc = l;
    loc2 = vel.copy();
    loc2.normalizeTo(len);
    //loc2.normalizeTo(len);
    timer = 100.0;
    //try this
    //timer = 30.0;
  }

  //FUNCTIONS
  void run() {
    update();
    render();
  }

  void update() {
    vel.addSelf(acc);
    loc.addSelf(vel);
    loc2.addSelf(vel);
    timer -= 1.0;
  }

  void render() {  
    //noStroke();
    if (timer > -1.0) {
      strokeWeight(1);
      stroke(colorr, colorg, colorb);
      //Line3D boner = new Line3D(loc, loc2);
      line(loc.x, loc.y, loc.z, loc2.x, loc2.y, loc2.z);
      //strokeWeight(10);
      //stroke(255, 0, 0);
      //point(loc.x, loc.y, loc.z);
      //stroke(0, 0, 255);
      //point(loc2.x, loc2.y, loc2.z);
      //ellipse(loc.x, loc.y, r * (1000 - timer), r * (1000 - timer));
      //x = Line3D(loc, loc2);
    }
  }

  boolean dead() {
    if (timer <= 0.0) {
      return true;
    }
    else {
      return false;
    }
  }
}

Hello,

Total beginner here, working from Jose's video tutorials if you can't tell.  I'm trying to do the following: a bunch of lines of different random colors and lengths erupting from the middle of the screen ad infinitum.  I've pasted the code below which gets me lines of different lengths erupting from the middle of the screen in random directions, but I do not know how to get this process moving in time.  I want lines erupting from the middle of the screen at very brief but random intervals, and I want a lot of them, but I need this to keep going.  I also need these lines to "die" or do something similar once they get off screen.  I do not anticipate a problem with the random stroke color.

Finally I'm doing this with Toxic Libs Vec3D class.  If there is an eminently better way to do this please let me know.

Thanks,
Speank

//tab1

import toxi.geom.*;

ArrayList tomeCollection;

float speed = 15;

void setup()
{
  frameRate(30);
  size(1280, 720);
  smooth();

  //INITIALIZE
  tomeCollection = new ArrayList();

  for (int i = 0; i < 100; i++)
  {
    Vec3D angle = new Vec3D (random(-2000, 2000), random(-2000, 2000), 0);
    Vec3D plop = angle.copy();
    float len = random(15, 300);
    Tome myTome = new Tome(angle, plop, len);
    tomeCollection.add(myTome);
  };
}

void draw()
{
  translate(640, 360);
  background(230, 89, 40);
  for (int i = 0; i < 100; i++)
  {
    Tome mt = (Tome) tomeCollection.get(i);
    mt.run();
  }
}

//tab2

class Tome {
  //GLOBAL VARIABLES
  Vec3D vec2 = new Vec3D(0, 0, 0);
  Vec3D vec1 = new Vec3D(0, 0, 0);
  float k = 0.1;
  float u = 0.1;
  float len;
 
  //CONSTRUCTOR
  Tome(Vec3D _vec2, Vec3D _vec1, float _len) {
    vec2 = _vec2;
    vec1 = _vec1;
    len = _len;
  }

  //FUNCTIONS
  void run() {
    trod();
    display();
  }

  void trod() {
    vec2.normalizeTo(k);
    vec1.normalizeTo(u);
    k += speed;
    if(k > len) {
    u += speed; }
  }

  void display() {
    stroke(255);
    strokeWeight(10);
    line(vec1.x, vec1.y, vec2.x, vec2.y);
    stroke(255, 0, 10);
    stroke(0);
    strokeWeight(40);
    point(vec2.x, vec2.y);
  }
}

What is the best way to export video from Processing for use in After Effects, ultimately going into a Prores 422 HQ workflow in Final Cut Pro?  I am trying to utilize all Prores 422 HQ assets in After Effects as well, but I don't mind bringing something else in as long as it is high quality and plays nicely with Prores 422 HQ. 

the MovieMaker object gives me these codec options, ANIMATION, BASE, BMP, CINEPAK, COMPONENT, CMYK, GIF, GRAPHICS, JPEG, MS_VIDEO, MOTION_JPEG_A, MOTION_JPEG_B, RAW, SORENSON, VIDEO, H261, H263, H264.

and these compression options WORST, LOW, MEDIUM, HIGH, BEST, LOSSLESS.

As I do not see an option for Prores, my initial response is to go with ANIMATION and LOSSLESS.  ANIMATION in FCP is an uncompressed setting, so I would think it would be the way to go, but as I haven't worked with Processing much at all I cannot be sure.  I did check out this thread http://processing.org/discourse/yabb2/YaBB.pl?num=1211318862 which would seem to confirm my initial response, but I would like to know if anyone else has any other ideas.

Also, is there anyway to output video from Processing at exactly 29.97 fps?  MovieMaker seems only to allow integer values for fps.  I could change it later in After Effects, but I would rather get it out of Processing ready to go.

Drud

Hi, I am just having a heck of time determining where the MovieMaker object saves its movie files to!  Where are they?