Creating a undulating surface in processing??

farley_85

Creating a undulating surface in processing??

in Contributed Library Questions • 2 years ago

Hi guys,

could someone give me some much needed advise/pointers on how to achieve an undulating landscape in processing. I have posted below a sketch I'm working on. Basically I want an array of attractors moving randomly top of the grid of nodes. These attractors should distort the grid by moving those nodes that are within a defined distance in the z direction (+ or -). The movement of these nodes should be fluid in their movement.

My next step will be to implement some springs between the nodes so the grid becomes more like a surface or undulating landscape....or I was thinking that i should tie the nodes to a mesh and define this as the spring to achieve this effect. Does this sound right? Any advise comments would be gratefully received!

The pic below hopefully gives an idea of the overall surface form I'm trying to achieve.

Thanks,

Farley

import processing.opengl.*;

import peasy.*;

import toxi.physics.*;
import toxi.physics.constraints.*;
import toxi.physics.behaviors.*;
import toxi.geom.*;

// VARIABLES ////////////////////////////////////////

PeasyCam myCam;
Node myNode;
Attractor myAttractor;

int numNodesX = 60;
int numNodesY = 20;

int xInc = 20;
int yInc = 20;

int envX = numNodesX * xInc;
int envY = numNodesY * yInc;
int envZ = 400;

ArrayList nodeList = new ArrayList();

Vec3D testPos;

// Declare new physics world (array)
VerletPhysics myPhysics;

// ----------------------- // GLOBAL SETUP // -----------------------

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

// INITIALISE ////////////////////////////////////////

myCam = new PeasyCam(this, envX*2);
myCam.lookAt(envX/2, envX/2, envX/2);

myPhysics = new VerletPhysics();

myAttractor = new Attractor();

for (int i = 0; i < numNodesX; ++i) {
    for (int j = 0; j < numNodesY; ++j) {
      Vec3D nodeOrigin = new Vec3D ((i+0.5) * xInc, (j+0.5) * yInc, 0);
      Node tmpNode = new Node(nodeOrigin);
      nodeList.add(tmpNode);
    }
}
}

// ----------------------- // GLOBAL RUN // -----------------------

void draw() {
background(0);

stroke(100);
strokeWeight(0.8);
noFill();
pushMatrix();
translate(envX/2, envY/2, 0);
box(envX, envY, envZ);
popMatrix();

// RUN FUNCTIONS ////////////////////////////////////////

Vec3D v = new Vec3D(myAttractor.loc.x, myAttractor.loc.y, myAttractor.loc.z);
AttractionBehavior a = new AttractionBehavior(v, 100, 0.01);

myPhysics.addBehavior(a);

for (int i = 0; i < nodeList.size(); ++i) {
    Node myNode = (Node) nodeList.get(i);
    myNode.run();
}

myAttractor.run();

//drawParticles();

myPhysics.update();
}

// NAME ////////////////////////////////////////

class Node {

// DATA ////////////////////////////////////////

VerletParticle p;

// CONSTRUCTOR ////////////////////////////////////////

Node(Vec3D loc) {

    p = new VerletParticle(loc);
    myPhysics.addParticle(p);
}

// FUNCTIONS ////////////////////////////////////////

void run() {
    display();
}

void display() {
    strokeWeight(2);
    stroke(0, 0, 255);
    point (p.x, p.y, p.z);
}
}

// NAME ////////////////////////////////////////

class Attractor {

// DATA ////////////////////////////////////////

Vec3D loc = new Vec3D(0,0,50);
Vec3D vel = new Vec3D(1.5, 0.5, 0);

// CONSTRUCTOR ////////////////////////////////////////

Attractor() {
}

// FUNCTIONS ////////////////////////////////////////

void run() {
    move();
    bounce();
    display();
}

void move() {
    loc.addSelf(vel);
}

void bounce() {
    if (loc.x > envX || loc.x < 0) {
      vel.x *= -1;
    }
    if (loc.y > envY || loc.y < 0) {
      vel.y *= -1;
    }
}

void display() {
    strokeWeight(2);
    stroke(255, 0, 0);
    point (loc.x, loc.y, loc.z);
}
}

Replies(2)

Mike Alpo..

Re: Creating a undulating surface in processing??

2 years ago

Here is an example of an undulating surface that someone else kindly provided some time ago in one of these forums.

float[][] data = new float[100][100];

void setup()
{
size(1024, 768, P3D);

for(int i = 0; i < data.length; i++)
{
    for(int j = 0; j < data[i].length; j++)
    {
      data[i][j] = 100*sin(i/10.0)+100*cos(j/10.0);
    }
}
colorMode(RGB);
}

void draw()
{
background(0);
//lights();
spotLight(51, 102, 126, 80, 20, 40, -1, 0, 0, PI/2, 2);
directionalLight(255, 0, 0, 1,1,1);
//directionalLight(255, 0, 0, 10, 10, 10);
//ambientLight(0, 255, 0);

beginCamera();
camera(0, -500, 1500, 0, 0, 0, 0, 1, 0);
endCamera();

noStroke();
fill(255);

pushMatrix();
rotateY(millis()/10000.0);
//rotateY(mouseY*360/height);
translate(-500, 0, -500);
scale(10, 1, 10);

for(int i = 1; i < data.length; i++)
{
    for(int j = 1; j < data[i].length; j++)
    {
      beginShape();
      vertex(i, data[i][j], j);
      vertex(i, data[i][j-1], j-1);
      vertex(i-1, data[i-1][j-1], j-1);
      vertex(i-1, data[i-1][j], j);
      endShape();
    }
}
popMatrix();
}

farley_85

Re: Creating a undulating surface in processing??

2 years ago

Hey Mike, thanks for that. I actually managed to do (with a little help from the guys at supermanouvere.... http://www.supermanoeuvre.com/). Here it is for anyone who is interested:

// IMPORT EXTERNAL LIBRARIES
import processing.opengl.*;   // openGL library
import peasy.*;               // the camera library
import controlP5.*;           // the interface library

/*------------------------------------------------------------------
*** GLOBAL VARIABLES ***
------------------------------------------------------------------*/
// camera
PeasyCam theCamera;
float     bBox             = 800;                 // a size of environment
// inteface
ControlP5     theGUI;
ControlWindow theGUIWindow;

// ArrayLists of stuff
ArrayList springList        = new ArrayList();

// particle variables
int       numParticles      = 35;
Particle[][] particleList   = new Particle[numParticles][numParticles];

// spring variables
//PVector   gravity           = new PVector(0, 0, 0);
float     SPRING_RESTLENGTH = 10.0;    // the length a spring is at rest
float     SPRING_DAMPING    = 3.0;    // equiv hydraulic damping of a piston

// ArrayLists of attractors
ArrayList attList        = new ArrayList();
int numAttractors = 4;

/*------------------------------------------------------------------
*** GLOBAL SETUP ***
------------------------------------------------------------------*/
void setup() {

//----------general
size(900, 600, OPENGL);
background(0);

//----------make the camera
theCamera = new PeasyCam(this, bBox*1.65);
theCamera.lookAt(bBox/2, bBox/2, bBox/2);

//--setup interface
theGUI       = new ControlP5(this);
theGUIWindow = theGUI.addControlWindow("GUI_WINDOW", 100, 100, width, 300);
theGUIWindow.hideCoordinates();

Controller slider_springLength = theGUI.addSlider( "SPRING_RESTLENGTH", 1.0, 20.0, SPRING_RESTLENGTH, 25, 25, 250, 25 );
slider_springLength.setWindow(theGUIWindow);

Controller slider_springDamping = theGUI.addSlider( "SPRING_DAMPING", 1.0, 5.0, SPRING_DAMPING, 25, 75, 250, 25 );
slider_springDamping.setWindow(theGUIWindow);

//----------make particles
float gridInc = (float) bBox/(numParticles-1);
for (int i=0; i<numParticles; ++i) {
    for (int j=0; j<numParticles; ++j) {
      // make a vector
      PVector tmpPos = new PVector(i*gridInc, j*gridInc, bBox);
      // make a particle
      Particle newP = new Particle(tmpPos);

      // fix perimeter particles

        // fix 1st and last particle
      if ( (i < numParticles && j==0)
        || (i==0 && j < numParticles)
        || (i==numParticles-1 && j < numParticles)
        || (i < numParticles && j==numParticles-1) ) {
        newP.fixMe();
      }
      // store the particle in our list
      particleList[i][j] = newP;
    }
}

//----------make springs
Spring s0, s1;
for (int i=0; i<numParticles; ++i) {
    for (int j=0; j<numParticles; ++j) {

      if ( i>0 ) {
        s0 = new Spring( particleList[i][j], particleList[i-1][j] );
        springList.add(s0);
        particleList[i][j].addSpring(s0);
        particleList[i-1][j].addSpring(s0);
      }

      if ( j>0 ) {
        s1 = new Spring( particleList[i][j], particleList[i][j-1] );
        springList.add(s1);
        particleList[i][j].addSpring(s1);
        particleList[i][j-1].addSpring(s1);
      }
    }
}

// print how many springs we made
println("Number of springs " + springList.size() );

//----------make attractors
Attractor tmpAtt;
for (int i = 0; i < numAttractors; ++i) {
    PVector aPos = new PVector(random(0, gridInc*numParticles), random(0, gridInc*numParticles), random((bBox-200),(bBox-50)));
    PVector aVel = new PVector(random(-1.5, 1.5), random(-1.5, 1.5), 0);

    tmpAtt = new Attractor(aPos, aVel);
    attList.add(tmpAtt);
}
}

/*------------------------------------------------------------------
*** GLOBAL CONTINUOUS DRAW ***
------------------------------------------------------------------*/
void draw() {
//----------general
background(250);
//----------visualize our bounding box
showEnv();

//----------update particle physics
for (int i=0; i<numParticles; ++i) {
    for (int j=0; j<numParticles; ++j) {
      particleList[i][j].solveForce();
    }
}

//----------update particle positions
for (int i=0; i<numParticles; ++i) {
    for (int j=0; j<numParticles; ++j) {
      particleList[i][j].update();
    }
}

//----------update springs
for (int i=0; i<springList.size(); ++i) {
    // get a spring from the arraylist
    Spring currS = (Spring) springList.get(i);
    currS.showMe();
}

//----------draw attractors
for (int i = 0; i < numAttractors; ++i) {
    Attractor myAtt = (Attractor) attList.get(i);
    myAtt.run();
}
}

/*----------------------------------
*** DRAW THE BOUNDING BOX
-----------------------------------*/
void showEnv() {
stroke(180);
strokeWeight(0.8);
noFill();
pushMatrix();
translate(bBox/2, bBox/2, bBox);
box(bBox, bBox, bBox/2);
popMatrix();
}

class Attractor {

/*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
PVector aPos;
PVector aVel;
float aForce;

/*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/

Attractor(PVector aPos_, PVector aVel_) {

    // assign all the class variables
    aPos = aPos_;
    aVel = aVel_;
}

/*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

void run() {
    move();
    bounce();
    display();
}

void move() {
    aPos.add(aVel);
}

void bounce() {
    if (aPos.x > bBox) {
      aVel.x *= -1;
    }
    if (aPos.x < 0) {
      aVel.x *= -1;
    }
    if (aPos.y > bBox) {
      aVel.y *= -1;
    }
    if (aPos.y < 0) {
      aVel.y *= -1;
    }
}

void display() {
    strokeWeight(3);
    stroke(255, 0, 0);
    point(aPos.x, aPos.y, aPos.z);
}
}

class Particle {

/*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
int       pID;
PVector   pos;
PVector   vel;
PVector   acc;
float     pSize;
boolean   pFixed;

ArrayList conSprings = new ArrayList();

/*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
Particle(PVector STARTPOS) {
    // assign all the class variables
    pos    = STARTPOS;
    vel    = new PVector();
    acc    = new PVector();
    pSize = 10.0;
    pID    = 0;
    pFixed = false;
}

/*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

//----------MOVE AND DRAW TO SCREEN
void update() {
    if (pFixed==false) {
      updatePos();
      attraction();
      }
      showMe();
}

//----------SOLVE THE SPRINGS
void solveForce() {

    if (pFixed==false) {

      Particle otherP;
      PVector sumForces = new PVector();
      //sumForces.add(gravity);
      sumForces.add(acc);

      // loop thru our connections
      for (int i = 0; i<conSprings.size(); ++i) {
        // get a spring
        Spring s = (Spring) conSprings.get(i);
        // get other end of spring
        if ( s.p00 == this ) {
          otherP = s.p01;
        }
        else {
          otherP = s.p00;
        }
        // calculate the push/pull of spring
        PVector vecBet     = PVector.sub(otherP.pos, pos);
        float   currLen    = vecBet.mag();
        float   desiredLen = currLen-SPRING_RESTLENGTH;
        vecBet.normalize();
        vecBet.mult(desiredLen/2);
        // add this force to our sum of forces
        sumForces.add(vecBet);
      }
      // apply a damping to the force
      sumForces.mult(SPRING_DAMPING);
      // add the resultant force to our vel
      vel.add(sumForces);
    }
}

void updatePos() {
    vel.add(acc);
    vel.limit(2);
    pos.add(vel);
    acc = new PVector(0, 0, 0);

    /*pos.add(vel);              // move the particle
     vel.mult(0);    */    // reset the vel for next time
}

//----------A typical class function!!
void showMe() {
    // set appearance
    noFill();
    if (pFixed==true) {
      // draw as 'FIXED' geometry
      strokeWeight(1);
      stroke(0, 0, 250,100);
      line(pos.x-pSize, pos.y, pos.z, pos.x+pSize, pos.y, pos.z);
      line(pos.x, pos.y-pSize, pos.z, pos.x, pos.y+pSize, pos.z);
      line(pos.x, pos.y, pos.z-pSize, pos.x, pos.y, pos.z+pSize);
    }
    else {
      // draw as 'FREE' geometry
      strokeWeight(0.5);
      stroke(100);
      line(pos.x-pSize/2, pos.y, pos.z, pos.x+pSize/2, pos.y, pos.z);
      line(pos.x, pos.y-pSize/2, pos.z, pos.x, pos.y+pSize/2, pos.z);
      line(pos.x, pos.y, pos.z-pSize/2, pos.x, pos.y, pos.z+pSize/2);
    }
}

//----------Make the particle fixed / free
void fixMe() {
    pFixed=true;
}
void freeMe() {
    pFixed=false;
}

//----------Add a spring to my list of springs
void addSpring(Spring S) {
    // store this spring
    conSprings.add(S);
}

void attraction() {
    PVector steer = new PVector();
    int count = 0;

    for (int i = 0; i < attList.size(); i++) {
      // get a PVector from the list
      Attractor tmpAtt = (Attractor) attList.get(i);
      float distance = PVector.dist(tmpAtt.aPos, pos);

      if (distance > 0 && distance < 200) {

        PVector vecBetween = PVector.sub(tmpAtt.aPos, pos);
        // get the length of the vector
        //float   distBetween = vecBetween.mag();
        vecBetween.normalize();

        steer.add(vecBetween);
        count++;
      }
    }
    if (count > 0) {
      steer.mult(1.0/count);
    }

    steer.mult(2);
    acc.add(steer);
}
}

class Spring {

/*------------------------------------------------------------------
   *** CLASS VARIABLES ***
   ------------------------------------------------------------------*/
// declare all the class variables
Particle p00;
Particle p01;

/*------------------------------------------------------------------
   *** CLASS CONSTRUCTOR ***
   ------------------------------------------------------------------*/
Spring (Particle INPUT_00, Particle INPUT_01) {
    // assign all the class variables
    p00 = INPUT_00;
    p01 = INPUT_01;
}

/*------------------------------------------------------------------
   *** CLASS FUNCTIONS ***
   ------------------------------------------------------------------*/

//----------Draw myself
void showMe() {
    stroke(180);
    strokeWeight(1);
    noFill();
    line(
    p00.pos.x, p00.pos.y, p00.pos.z,
    p01.pos.x, p01.pos.y, p01.pos.z
      );
}
}

Top Reply