OpenCode

OPENCODE is a web-based programming environment that leverages the user community to foster creative development and teach graphics-based programming to non-programmers. Sign up for an account now!

//path aligner
// by irag

//import processing.opengl.*;

int pathNodeCount = 1000;
// Any path can be used, as spine of Tendril
Vector3D[] path = new Vector3D[pathNodeCount];
Tendril tendril;

void setup(){
  size(400, 400, P3D);
  background(255, 255, 255);
  frameRate(30);
  float px=0.0f, py=0.0f, pz=0.0f, ang=0.0f, ang2 = 0.0f, ang3 = 0.0f, rad=10.0f;
  float tx = 0.0f, ty = 0.0f, tz = 0.0f;

// generate points along any path
  for (int i=0; i<pathNodeCount; i++) {
    // Standard coil
    // px = sin(ang)*rad;
    // pz = cos(ang)*rad;
    // py += .8;

// Less structured form
    /* px = sin(ang)*rad*1.2;
     pz = cos(ang)*rad-sin(ang2/2.5)*rad*1.7;
     py += .7;
     */

// ball of thread - around y-axis
    px = sin(ang)*rad;
    pz = cos(ang)*rad;
    //py += .4;

// x-axis
    ty = cos(ang2)*py-sin(ang2)*pz;
    tz = sin(ang2)*py+cos(ang2)*pz;
    py = ty;
    pz = tz;

// z-axis
    tx = cos(ang3)*px-sin(ang3)*py;
    ty = sin(ang3)*px+cos(ang3)*py;
    px = tx;
    py = ty;

// Create path
    path[i] = new Vector3D(px, py, pz);
    ang += TWO_PI/64;
    ang2-= TWO_PI/150;
    ang3+= TWO_PI/190;
    rad+=.19;

}
  tendril = new Tendril(path, 4, 8);
}

void draw(){
  background(255, 255, 255);
  translate(width/2, height/2);
  lights();
  rotateX(frameCount*PI/180);
  rotateY(frameCount*PI/220);
  rotateZ(frameCount*PI/160);
  noStroke();
  noFill();
  //noFill();

stroke(255, 255, 255);
   //tendril.create(IGConsts.RENDER_PATH);
   
   stroke(255, 150, 0);
  // tendril.create(IGConsts.RENDER_CAGE);

// noStroke();
  stroke(255, 0, 0, 255);
  tendril.create(IGConsts.RENDER_SKIN);
  
}

interface IGConsts{
  static int X_AXIS = 0;
  static int Y_AXIS = 1;
  static int Z_AXIS = 2;
  
  static int RENDER_PATH = 3;
  static int RENDER_CAGE = 4;
  static int RENDER_SKIN = 5;
}

class Polygon3D{

Vector3D origin = new Vector3D(0, 0, 0);
  int vectorCount = 8;
  float radius = 50;
  Vector3D[] vecs;
  int axisAlignment = IGConsts.X_AXIS;

Polygon3D(){
    init();
  }

Polygon3D(Vector3D origin, int vectorCount, float radius, int axisAlignment){
    this.origin = origin;
    this.vectorCount = vectorCount;
    this.radius = radius;
    this.axisAlignment = axisAlignment;
    vecs = new Vector3D[vectorCount];
    init();
  }

// init geometry
  void init(){
    float px=0, py=0, pz=0, angle=0;
    switch(axisAlignment){
    case IGConsts.X_AXIS:
      px = origin.x;
      pz = origin.z + cos(radians(angle))*radius;
      py = origin.y + sin(radians(angle))*radius;
      vecs[0] =  new Vector3D(px, py, pz);
      angle+=360/vectorCount;
      for (int i=1; i<vectorCount; i++){
        pz = origin.z + cos(radians(angle))*radius;
        py = origin.y + sin(radians(angle))*radius;
        vecs[i] =  new Vector3D(px, py, pz);
        angle+=360/vectorCount;
      }
      break;
    case IGConsts.Y_AXIS:
      py = origin.y;
      px = origin.x + cos(radians(angle))*radius+random(-3, 3);
      pz = origin.z + sin(radians(angle))*radius+random(-3, 3);
      vecs[0] =  new Vector3D(px, py, pz);
      angle+=360/vectorCount;
      for (int i=1; i<vectorCount; i++){
        px = origin.x + cos(radians(angle))*radius+random(-3, 3);
        pz = origin.z + sin(radians(angle))*radius+random(-3, 3);
        vecs[i] =  new Vector3D(px, py, pz);
        angle+=360/vectorCount;
      }
      break;
    case IGConsts.Z_AXIS:
      pz = origin.z;
      px = origin.x + cos(radians(angle))*radius;
      py = origin.y + sin(radians(angle))*radius;
      vecs[0] =  new Vector3D(px, py, pz);
      angle+=360/vectorCount;
      for (int i=1; i<vectorCount; i++){
        px = origin.x + cos(radians(angle))*radius;
        py = origin.y + sin(radians(angle))*radius;
        vecs[i] =  new Vector3D(px, py, pz);
        angle+=360/vectorCount;
      }
      break;
    }
  }

// draw polys
  void create(){
    beginShape();
    for (int i=0; i<vecs.length; i++){
      vertex(vecs[i].x, vecs[i].y, vecs[i].z);
    }
    endShape(CLOSE);
  }
}

public class Tendril{
  // Initial path
  private Vector3D[] path;
  // Vectors between path nodes
  public Vector3D[] regVecs;
  // Cage polygons
  Polygon3D[] polys;
  private float xzAng, yzAng, xyAng;
  private float tempX, tempY, tempZ;
  private Vector3D worldOrigin = new Vector3D(0.0f,0.0f,0.0f);
  // Number of points on cage polygons
  private int polyDetail;
  // Tendril thickness
  private float polyRadius;

private int polyCounter = 0;

public Tendril(Vector3D[] path, int polyDetail, float polyRadius){
    this.path = path;
    this.polyDetail = polyDetail;
    this.polyRadius = polyRadius;
    init();
  }

private void init(){
    regVecs = new Vector3D[path.length-1];
    polys = new Polygon3D[path.length-1];
    // generate vectors between each point on path
    for (int i=1; i<path.length; i++) {
      regVecs[i-1] = new Vector3D(path[i].x-path[i-1].x, path[i].y-path[i-1].y, path[i].z-path[i-1].z);
    }

// 1. Calculate angles of rotation of path vectors in
    // reference to y and z-axes. 
    // 2. Use these values to transform vectors to 
    // orthogonal orientation.
    for (int i=0; i<regVecs.length; i++) {
      // Rotate around y-axis
      xzAng = atan2(regVecs[i].x, regVecs[i].z); // need this angle later
      tempZ = (float)(Math.cos(-xzAng+PI/2) * regVecs[i].z - Math.sin(-xzAng+PI/2) * regVecs[i].x);
      tempX = (float)(Math.sin(-xzAng+PI/2) * regVecs[i].z + Math.cos(-xzAng+PI/2) * regVecs[i].x);
      regVecs[i].z = tempZ;
      regVecs[i].x = tempX;

// Rotate around z-axis
      xyAng = atan2(regVecs[i].y, regVecs[i].x); // need this angle later
      tempX = (float)(Math.cos(-xyAng) * regVecs[i].x - Math.sin(-xyAng) * regVecs[i].y);
      tempY = (float)(Math.sin(-xyAng) * regVecs[i].x + Math.cos(-xyAng) * regVecs[i].y);
      regVecs[i].x = tempX;
      regVecs[i].y = tempY;

// 1. Construct polygons at world origin with same othogonal 
      // orientation as transformed vectors above.
      // (orientation is parallel to x-axis)
      // 2. Translate polygons back to original positions.
      polys[i] = new Polygon3D(worldOrigin, polyDetail, polyRadius, IGConsts.X_AXIS);
      polys[i].init();

// Reverse order of vector rotations for
      // polygons. This order should mirror 
      // order of original sequence of rotations
      // e.g. AB = BA).
      for (int j=0; j<polys[i].vecs.length; j++){
        // Reverse Z-axis rotation by inverting 
        // theta (xzAng to -xzAxg) and use this value
        // to rotate polygons.
        tempX = (float)(Math.cos(xyAng) * polys[i].vecs[j].x - Math.sin(xyAng) * polys[i].vecs[j].y);
        tempY = (float)(Math.sin(xyAng) * polys[i].vecs[j].x + Math.cos(xyAng) * polys[i].vecs[j].y);
        polys[i].vecs[j].x = tempX;
        polys[i].vecs[j].y = tempY;

// Reverse Y-axis rotation by inverting 
        // theta (-xzAng+PI/2 to xzAng-PI/2) and use this value
        // to rotate polygons. 
        tempZ = (float)(Math.cos(xzAng-PI/2) * polys[i].vecs[j].z - Math.sin(xzAng-PI/2) * polys[i].vecs[j].x);
        tempX = (float)(Math.sin(xzAng-PI/2) * polys[i].vecs[j].z + Math.cos(xzAng-PI/2) * polys[i].vecs[j].x);
        polys[i].vecs[j].z = tempZ;
        polys[i].vecs[j].x = tempX;

// translate polygons back to original positions
        polys[i].vecs[j].add(path[i]);
      }
    }
  }

public void create(int renderDetail){
    switch(renderDetail){
    case IGConsts.RENDER_PATH:
      drawPath();
      break;
    case IGConsts.RENDER_CAGE:
      drawCage();
      break;
    case IGConsts.RENDER_SKIN:
      drawSkin();
      break;
    default:
      drawSkin();
    }
  }

private void drawPath(){
    beginShape();
    for (int i=0; i<polyCounter; i++) {
      vertex(path[i].x, path[i].y, path[i].z);
    }
    endShape();
    if (polyCounter<polys.length){
      polyCounter+=1;
    }
  }

private void drawCage(){
    for (int i=0; i<polyCounter; i+=1){
      polys[i].create();
    }
    if (polyCounter<polys.length){
      polyCounter+=1;
    }
  }

private void drawSkin(){
    //for (int i=1; i<polys.length; i+=1){
    for (int i=1; i<polyCounter; i+=1){
      for (int j=1; j<polys[i].vecs.length; j++){
        if(j==1){
          noStroke();
          pushMatrix();
          fill(200, 200, 255);
          translate(polys[i-1].vecs[j-1].x, polys[i-1].vecs[j-1].y, polys[i-1].vecs[j-1].z);
          box(3, 3, 3);
          popMatrix();
        }
        noFill();
        stroke(0);
        beginShape(QUADS);
        vertex(polys[i-1].vecs[j-1].x, polys[i-1].vecs[j-1].y, polys[i-1].vecs[j-1].z);
        vertex(polys[i].vecs[j-1].x, polys[i].vecs[j-1].y, polys[i].vecs[j-1].z);
        vertex(polys[i].vecs[j].x, polys[i].vecs[j].y, polys[i].vecs[j].z);
        vertex(polys[i-1].vecs[j].x, polys[i-1].vecs[j].y, polys[i-1].vecs[j].z);
        endShape();
        // close tube
        if (j==polys[i].vecs.length-1){
          beginShape(QUADS);
          vertex(polys[i-1].vecs[j].x, polys[i-1].vecs[j].y, polys[i-1].vecs[j].z);
          vertex(polys[i].vecs[j].x, polys[i].vecs[j].y, polys[i].vecs[j].z);
          vertex(polys[i].vecs[0].x, polys[i].vecs[0].y, polys[i].vecs[0].z);
          vertex(polys[i-1].vecs[0].x, polys[i-1].vecs[0].y, polys[i-1].vecs[0].z);
          endShape();
        }
      }
    }
    if (polyCounter<polys.length){
      polyCounter+=1;
    }
  }
}

class Vector3D{
  float x, y, z;
  float[]origVals;

Vector3D(){
  }

Vector3D(float x, float y, float z){
    this.x = x;
    this.y = y;
    this.z = z;

// capture original values
    origVals  = new float[]{ 
      x, y, z     };
  }

//methods
  void add(Vector3D v){
    x+=v.x;
    y+=v.y;
    z+=v.z;
  }

void subtract(Vector3D v){
    x-=v.x;
    y-=v.y;
    z-=v.z;
  }

void multiply(float s){
    x*=s;
    y*=s;
    z*=s;
  }

void divide(float s){
    x/=s;
    y/=s;
    z/=s;
  }

Vector3D getAverage(Vector3D v){
    Vector3D u = new Vector3D();
    u.x = (x+v.x)/2;
    u.y = (y+v.y)/2;
    u.z = (z+v.z)/2;
    return u;
  }

void setTo(Vector3D v){
    x = v.x;
    y = v.y;
    z = v.z;
  }

void reset(){
    x = origVals[0];
    y = origVals[1];
    z = origVals[2];
  }

float getDotProduct(Vector3D v){
    return x*v.x + y*v.y + z*v.z;
  }

Vector3D getCrossProduct(Vector3D v, Vector3D u){
    Vector3D v1 = new Vector3D(v.x-x, v.y-y, v.z-z);
    Vector3D v2 = new Vector3D(u.x-x, u.y-y, u.z-z);
    float xx = v1.y*v2.z-v1.z*v2.y;
    float yy = v1.z*v2.x-v1.x*v2.z;
    float zz = v1.x*v2.y-v1.y*v2.x;
    return new Vector3D(xx, yy, zz);
  }

Vector3D getNormal(Vector3D v, Vector3D u){
    Vector3D n = getCrossProduct(v, u);
    n.normalize();
    return(n);
  }

void normalize(){
    float m = getMagnitude();
    x/=m;
    y/=m;
    z/=m;
  }

public float getMagnitude(){
    return sqrt(x*x+y*y+z*z);
  }
}