Hi

I've been considering Verlet integration and thought I'd set up a test to see how it compared with Euler. The below code initially looked to compare the Euler calculation (the red line) to Verlet (the blue). Given how horrendously awful Euler is supposed to be I was expecting to see an immediate visible result but they tracked accurately together.

I added the println calculating the accurate offset value (referred to as "Newtonian")  and compared it at regular time steps to the comparable Euler and Verlet values. When I run this sketch both Euler and Verlet show largely identical (the small differences down to float precision?) errors compared to the newtonian value until the Verlet value eventually, and inexplicably, starts to deviate more dramatically.

I thought Verlett was supposed to be more accurate? I'm guessing it's a code error but not sure where I've gone wrong on this one. Any help appreciated.

Thanks

Matt

1. float deltaTime;
   float cumulativeTime;
   PVector globalAcceleration;
   EulerMover eulerMover;
   VerletMover verletMover;
   
   void setup() {
     size(1000, 600, P3D);
     smooth(5);
     frameRate(50);
   
     deltaTime = 1;
     cumulativeTime = 0;
     globalAcceleration = new PVector(0.1, 0);
     eulerMover = new EulerMover();
     verletMover = new VerletMover();
   }
   
   void draw() {
     translate(0, height/2);
   
     eulerMover.update();
     verletMover.update();
   
     eulerMover.display();
     verletMover.display();
   
     cumulativeTime += deltaTime;
     if (cumulativeTime%200==0) {
       println("Newtonian = "+(0.5*globalAcceleration.x*sq(cumulativeTime))+", Euler = "+eulerMover.location.x+", Verlet = "+verletMover.location.x);
     }
   }
   
   class EulerMover {
     PVector location;
     PVector velocity;
     PVector acceleration;
     EulerMover() {
       location = new PVector(0, 0);
       velocity = new PVector(0, 0);
       acceleration = globalAcceleration.get();
     }
     void update() {
       PVector deltaAcceleration = PVector.mult(acceleration, deltaTime);
       velocity.add(deltaAcceleration);
       PVector deltaVelocity = PVector.mult(velocity, deltaTime);
       location.add(deltaVelocity);
     }
     void display() {
       stroke(255, 0, 0);
       line(location.x, location.y, location.x, location.y-20);
     }
   }
   
   class VerletMover {
     PVector location;
     PVector previousLocation;
     PVector acceleration;
     VerletMover() {
       location = new PVector(0, 0);
       previousLocation = new PVector(0, 0);
       acceleration = globalAcceleration.get();
     }
     void update() {
       PVector deltaLocation = PVector.sub(location, previousLocation);
       PVector deltaAcceleration = PVector.mult(acceleration, sq(deltaTime));
       PVector increment = PVector.add(deltaLocation, deltaAcceleration);
       previousLocation = location.get();
       location.add(increment);
     }
     void display() {
       stroke(0, 0, 255);
       line(location.x, location.y, location.x, location.y+20);
     }
   }
   
   

Hi

Just downloaded 2.0b9 and excitedly fired it up to see how some of my sketches ran and... nothing. Tried another sketch... nothing. Tried an empty sketch with just basic size(500,500) definition and background(255,0,0) in draw()... nothing. Tried one of the example files... nothing.

Thought it might be a java issue so quitted, installed latest java update, rebooted machine, fired up processing and... nothing.

Yellow play icon lights up but no sketch window opens. I can stop the app by pressing the stop button but there's no evidence of anything stopping.

I hesitate to post it as a bug so soon as it seems pretty, um, significant! Any pointers to other hardware/configuration/software updates that could be reponsible?

I'm running Vista on a Dell XPS with Nvidia hardware. All previous Betas ran just fine :-(

Thanks

Matt 

Hi

I've read a couple of forum posts that come close to this topic but no explicit examples. I'm trying to mask the contents of one PGraphic with a mask image generated dynamically in another. I've put together some simple test code below. I'd expect to see a red circle moving over a black background but I just get a sea of red. Enabling/Disabling the commented lines gets a bit closer inasmuch as  you can see some black fringing around a red circle on a red background, so something is going on!

Any pointers as to why this isn't working or how to achieve the desired effect?

Thanks in advance

Matt

1. PGraphics maskGraphic;
   PGraphics displayGraphic;
   
   void setup() {
     size(1000, 600, P2D);
     maskGraphic = createGraphics(1000, 600, P2D);
     displayGraphic = createGraphics(1000, 600, P2D);
   }
   
   void draw() {
     background(0);
   
     maskGraphic.beginDraw();
     maskGraphic.background(0);
     maskGraphic.noStroke();
     maskGraphic.fill(255);
     maskGraphic.ellipse(mouseX, mouseY, 300, 300);
     maskGraphic.endDraw();
   
     displayGraphic.beginDraw();
     displayGraphic.background(255, 0, 0);
     //displayGraphic.mask(maskGraphic); //implementing the mask line here reveals the mask shape but doesn't exclude the background red 
     displayGraphic.endDraw();
   
     displayGraphic.mask(maskGraphic); //I'd expect the line here to work but it doesn't mask anything
   
     image(displayGraphic, 0, 0);
   }
   

Hi

I'm working on some basic 3D physics and I'm trying to get a point to bounce off an inclined plane. After scouring the web I think I've got a reliable way of detecting when the point's velocity vector intersects the plane defined by the three vertices of the triangle. I also think I've got a working way of detecting if that velocity/plane intersection point lies within the triangle defined by the three vertices. I think I've also got a working way of calculating the reflection vector of the velocity against the plane. So far so good. What I don't have working reliably is when the point has reliably collided with the plane. As you can see from the code below I'm doing a comparison on the y axis values and confirming that the velocity vector points downward. While this test largely works it triggers a false positive at the apex of the bounce forcing an unnatural return trajectory.

So, the question is, what is the best way to test for the point/plane intersection conditions being true? And I guess secondly, have I made a stupid mistake somewhere else that's leading to this behaviour? I'd like to allow for perfectly elastic collisions in the first instance with the opportunity to apply a coefficient of restitution ultimately. 

Happy to take hints rather than outright solutions as I'd prefer to solve myself if possible...but this has been bugging me for a few days now!

Thanks in advance for any assistance

Cheers

Matt

PS I know this can all be done with toxilibs but I'd like to try and roll my own solution out of curiosity's sake in the first instance.

1. PVector gravity;
   InclinedPlane inclinedPlane;
   int moverCount;
   Mover[] moverList;
   
   void setup() {
     size(1000, 600, P3D);
     colorMode(RGB, 255, 255, 255, 255);
     noStroke();
     smooth(5);
   
     gravity = new PVector(0, -0.01, 0);
   
     inclinedPlane = new InclinedPlane();
   
     moverCount = 1;
     moverList = new Mover[moverCount];
     for (int i=0; i< moverCount; i++) {
       moverList[i] = new Mover();
     }
   }
   
   void draw() {
     background(100);
     translate(width/2, (height/4)*3, 0);
     rotateY(mouseX/200.0);
     lights();
   
     inclinedPlane.render();
   
     for (int i=0; i< moverCount; i++) {
       moverList[i].applyForce(gravity);
       moverList[i].update();
       moverList[i].render();
     }
   }
   
   class Mover {
     PVector location;
     PVector velocity;
     PVector acceleration;
     Mover() {
       location = new PVector(random(100), 400, random(-100));
       velocity = new PVector(0, 0, 0);
       acceleration = new PVector(0, 0, 0);
     }
   
     void applyForce(PVector inputForce) {
       acceleration.add(inputForce);
     }
   
     void update() {
       velocity.add(acceleration);
       location.add(velocity);
       acceleration.mult(0);
   
       PVector intersectionPoint = inclinedPlane.getRayIntersection(location, velocity);
      
       if (velocity.y<0&&location.y < intersectionPoint.y) {//is this the best test?
         if (inclinedPlane.isPointInTriangle(intersectionPoint)) {
           velocity = inclinedPlane.getReflectionVector(velocity);
         }
       }
     }
   
     void render() {
       pushStyle();
       pushMatrix();
       translate(location.x, -location.y, location.z);
       ambient(128, 0, 0);
       fill(255, 0, 0);
       sphere(5);
       popMatrix();
       popStyle();
     }
   }
   
   class InclinedPlane {
     PVector vertex1;
     PVector vertex2;
     PVector vertex3;
     PVector centroid;
     PVector planeNormal;
     float normalDisplayLength;
     PVector displayNormal;
     PVector pointInPlane;
   
     InclinedPlane() {
       vertex1 = new PVector(0, 0, 0);
       vertex2 = new PVector(200, 100, 0);
       vertex3 = new PVector(0, 50, -200);
   
       PVector planeVector1_2 = PVector.sub(vertex2, vertex1);
       PVector planeVector1_3 = PVector.sub(vertex3, vertex1);
   
       PVector midPlaneVector1_2 = PVector.div(planeVector1_2, 2);
       PVector bisection = PVector.sub(midPlaneVector1_2, vertex3);
       bisection.mult(2/3.0);
       centroid = PVector.add(vertex3, bisection);
   
       planeNormal = planeVector1_2.cross(planeVector1_3);
       planeNormal.normalize();
       normalDisplayLength = 20;
       displayNormal = PVector.mult(planeNormal, normalDisplayLength);
   
       pointInPlane = new PVector(0, 0, 0);
     }
   
     PVector getRayIntersection(PVector inputOrigin, PVector inputVector) {
   
       PVector normalisedInput = inputVector.get();
       normalisedInput.normalize();
       PVector pointOffset = PVector.sub(vertex1, inputOrigin);
       float dot1 = PVector.dot(planeNormal, pointOffset);
       float dot2 = PVector.dot(planeNormal, normalisedInput);
       float t = dot1/dot2;
       PVector scaledVector = PVector.mult(normalisedInput, t);
       pointInPlane = PVector.add(inputOrigin, scaledVector);
   
       return pointInPlane;
     }
   
     PVector getReflectionVector(PVector inputVector) {
   
       PVector normalisedInput = inputVector.get();
       normalisedInput.normalize();
       float doubleDotProduct = 2 * PVector.dot(normalisedInput, planeNormal);
       PVector scaledNormal = PVector.mult(planeNormal, doubleDotProduct);
       PVector reflectionVector = PVector.sub(normalisedInput, scaledNormal);
   
       return reflectionVector;
     }
   
     boolean isPointInTriangle(PVector inputPoint) {
   
       // Compute vectors       
       PVector v0 = PVector.sub(vertex3, vertex1);
       PVector v1 = PVector.sub(vertex2, vertex1);
       PVector v2 = PVector.sub(inputPoint, vertex1);
   
       // Compute dot products
       float dot00 = PVector.dot(v0, v0);
       float dot01 = PVector.dot(v0, v1);
       float dot02 = PVector.dot(v0, v2);
       float dot11 = PVector.dot(v1, v1);
       float dot12 = PVector.dot(v1, v2);
   
       // Compute barycentric coordinates
       float invDenom = 1 / ((dot00 * dot11) - (dot01 * dot01));
       float u = ((dot11 * dot02) - (dot01 * dot12)) * invDenom;
       float v = ((dot00 * dot12) - (dot01 * dot02)) * invDenom;
   
       // Check if point is in triangle
       if ((u >= 0) && (v >= 0) && (u + v < 1)) {
         return true;
       }
       else {
         return false;
       }
     }
   
     void render() {
       pushStyle();
       stroke(0, 0, 255);
       line(centroid.x, -centroid.y, centroid.z, centroid.x+displayNormal.x, -(centroid.y+displayNormal.y), centroid.z+displayNormal.z);
       popStyle();
   
       pushStyle();
       pushMatrix();
       translate(pointInPlane.x, -pointInPlane.y, pointInPlane.z);
       fill(0, 255, 0);
       ambient(0, 128, 0);
       sphere(2);
       popMatrix();
       popStyle();
   
       fill(130);
       beginShape();
       vertex(vertex1.x, -vertex1.y, vertex1.z);
       vertex(vertex2.x, -vertex2.y, vertex2.z);
       vertex(vertex3.x, -vertex3.y, vertex3.z);
       endShape();
     }
   }
   
   

Hi

I'm having difficulty getting Twitter4j (v3.0.3) working under Processing 2.0b7. I've downloaded, unzipped, copied and renamed the files correctly (I think) into the sketchbook's libraries folder. Using the code below from the tutorial at

http://blog.blprnt.com/blog/blprnt/updated-quick-tutorial-processing-twitter

I get a 'Cannot find a class or type named "Configuration Builder"' error. I'm pretty sure I've imported the library correctly because if I rename the import line to import twitter5j.* or some other non-existent library it throws an error.

Any ideas what could be going wrong?

Thanks

Matt

1. import twitter4j.*;
   
   ConfigurationBuilder cb;
   Twitter twitter;
   
   void setup() {
     cb = new ConfigurationBuilder();
     cb.setOAuthConsumerKey("MpmV1xOOFociwNjp3FNfA");
     cb.setOAuthConsumerSecret("fjlsBtF98cq0VuCHXLQ78uyOz7fr8lm9WLhFbb4aU");
     cb.setOAuthAccessToken("6038892-lHWqBpkKhfAsJkCtyEeB3XORn9sGZP3PEy5L7eRKtk");
     cb.setOAuthAccessTokenSecret("REyXt8jvTdGUH3UkvGRJcXzB0nAGCjWvc39IlpM2NY");
   
     twitter = new TwitterFactory(cb.build()).getInstance();
   
     Query query = new Query("#processing");
     query.setRpp(100);
   
     try {
       QueryResult result = twitter.search(query);
       ArrayList tweets = (ArrayList) result.getTweets();
   
       for (int i = 0; i < tweets.size(); i++) {
         Tweet t = (Tweet) tweets.get(i);
         String user = t.getFromUser();
         String msg = t.getText();
         Date d = t.getCreatedAt();
         println("Tweet by " + user + " at " + d + ": " + msg);
       };
     }
     catch (TwitterException te) {
       println("Couldn't connect: " + te);
     };
   }
   
   void draw() {
   }
   
   

Hi

Anyone know why the retained mode code below doesn't apply the fill colours appropriately as per the non-retained mode version? Is this a bug or is there a different syntax for per-vertex fill settings in retained mode?

Thanks for any help

Matt

1. PShape testShape;
   
   void setup() {
     size(200, 200, P3D);
     colorMode(RGB, 255, 255, 255);
     noStroke();
   
     testShape = createShape();
     testShape.fill(255, 0, 0);
     testShape.vertex(50, 50);
     testShape.fill(255, 0, 255);
     testShape.vertex(150, 50);
     testShape.fill(0, 0, 255);
     testShape.vertex(150, 150);
     testShape.fill(0, 255, 255);
     testShape.vertex(50, 150);
     testShape.end();
   }
   
   void draw() {
     background(100, 100, 100);
   
     if (mousePressed) {
       shape(testShape);
     }
     else {
       beginShape();
       fill(255, 0, 0);
       vertex(50, 50);
       fill(255, 0, 255);
       vertex(150, 50);
       fill(0, 0, 255);
       vertex(150, 150);
       fill(0, 255, 255);
       vertex(50, 150);
       endShape(CLOSE);
     }
   }
   

Hi

I posted a question a week or so ago about Gouraud shading which (thanks to help from amonon.owed) was happily resolved. I've now run into some weird lighting issues when applying a texture which I'm generating procedurally at runtime. I've posted 2 screengrabs here showing how things should look and how they end up looking...

http://sdrv.ms/Z5Ljdh

Basically I'm reading in a low res heightmap in order to generate height values for my mountain model. I'm then recursively subdividing the vertex values in order to generate higher resolution vertex normals in order to calculate angles to the vertical which allows me to determine snow distribution before using this to create the higher res texture stored as a PImage. I'm then applying this texture to the lower res geometry, together stored as a retained mode object.

Here's the behaviour I see:

If I don't subdivide the basic height array values at all in order to generate the texture then everything is fine, albeit with a blocky texture

As soon as I apply any level of subdivision I start to see this blocky black error in the lighting of the model.

The black area creeps over the image based on viewing angle and can vary from being invisible (the firstscreenshot), through partial (the second) to completely covering the model.

The error appears with custom settings for both point and directional lights and the default 'lights()' setting. It doesn't appear if I specify no lights or just an ambient value.

I don't think its a UV mapping issue as my texture is appearing correctly as I'd expect over the model. I don't think it's a geometry issue as it works just fine with a low res texture and I don't think its an error in my lighting set up as it appears with lights() too. All told it's got me a bit stumped!

So does anyone recognise this visual glitch? It looks like some issue with the P3D renderer but I've been wrong on that one before so I'm hoping someone has some ideas that might point me in the right direction of a resolution. I'd post my source code but, as you can appreciate from the above, its fairly lengthy so thought I'd start with a description.

Really hope someone can help with this one, I'd hate not to be able to use my lovely procedural textures!

Thanks

Matt

Hi

I'm a relative newbie to Processing so apologies if this has been covered elsewhere (I have searched though!) I'm trying to implement a Gouraud shader in my processing sketch and have had no luck trying to create external GLSL files in my sketch's Data folder. I've copied source code from various sample files (found by searching for "GLSL Gouraud") and saved them as glsl files, either individually or as seperate Vertex and Fragment glsl files. Using the following syntax...

PShader gouraud;

void setup(){
      //usual setup stuff
      gouraud = loadShader("gouraud.glsl");
}

void draw(){
      shader(gouraud);
      //retained mode PShape and other vertex data follows
}


... I generally get an empty grey window when I run the sketch. So. Three questions...

1. Does anyone know of a working gouraud shader glsl file and appropriate syntax for inclusion in Processing?
2. If not, are there any plans to include one with the included Examples in a future Beta release? (would seem like a useful shader!)
3. Are there alternate methods using lower-level OpenGL calls that would achieve this aim? (I'm aware that in principle I could roll my own gouraud shader using vertex normals and per vertex fill settings but I was hoping for an out of the box solution - I have enough programming fish to fry with my project! ;-) )

Many thanks for any answers,

Matt