Processing

void setup(){
    size(200,200,P3D);
}

void setup(){
    size(200,200,OPENGL);
}

import processing.opengl.*;

void setup(){
    size(100,100,OPENGL);
}

import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.processing.*;

TriangleMesh mesh;
ToxiclibsSupport gfx;
void setup() {
  size(400, 400, P3D);
  gfx=new ToxiclibsSupport(this);
}
void draw() {
  // define a rounded cube using the SuperEllipsoid surface function
  SurfaceFunction f=new SuperEllipsoid(width/(mouseX+10), height/(mouseY+10));
  SurfaceMeshBuilder b = new SurfaceMeshBuilder(f);
  // execute the mesh (resolution=80, radius=100)
  mesh = (TriangleMesh)b.createMesh(null, 30, 60);
  background(128);
  fill(255);
  stroke(0);
  lights();
  translate(width / 2, height / 2, 0);
  rotateX(mouseY * 0.01f);
  rotateY(mouseX * 0.01f);
  gfx.mesh(mesh);
}


void keyPressed() {
  if (key=='e') {
    try {
      String fileID="shape-"+(System.currentTimeMillis()/1000);
      FileOutputStream fs;
      fs=new FileOutputStream(sketchPath(fileID+".stl"));
      mesh.saveAsSTL(fs);
    } 
    catch(Exception e) {
      e.printStackTrace();
    }
  }
}

import processing.opengl.*;

import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.processing.*;

TriangleMesh mesh = new TriangleMesh();


ToxiclibsSupport gfx;
int i=0;

void setup() {
  size(400,400,OPENGL);
  gfx=new ToxiclibsSupport(this);
}


void draw() {
  background(51);
  lights();
  translate(width / 2, height / 2, 0);
  rotateX(mouseY * 0.01f);
  noStroke();
  Vec3D BOX_SIZE = new Vec3D(mouseX/2,mouseY/2,mouseX/2);
  TriangleMesh b=(TriangleMesh)new AABB(new Vec3D(), BOX_SIZE).toMesh();
  gfx.mesh(b);
}


void keyPressed() {
  i++;
  if (key == 's') {
    mesh.saveAsSTL(sketchPath("cube"+i+".stl"));
  }
}

/**
 * SphericalHarmonicsMeshBuilder demonstrates how to use the SurfaceMeshBuilder class in conjunction with a spherical harmonics function to dynamically create a variety
 of organic looking forms. The function is described in detail on Paul Bourke's website. Included is also a re-usable function for displaying a generic TriangleMesh instance
 using normal mapping. the display of surface normals useful for debug purposes.
 
 r: randomize spherical harmonics
 w: toggle wireframe on/off
 n: toggle normal vector display on/off
 s: save current mesh as STL file
 
 * Copyright (c) 2010 Karsten Schmidt
 */

import processing.opengl.*;

import toxi.math.waves.*;
import toxi.geom.*;
import toxi.geom.mesh.*;

TriangleMesh mesh = new TriangleMesh();

boolean isWireFrame;
boolean showNormals;
boolean doSave;
int i=0;

Matrix4x4 normalMap = new Matrix4x4().translateSelf(128,128,128).scaleSelf(127);

void setup() {
  size(400,400, OPENGL);
  randomizeMesh();
}

void draw() {
  background(0);
  translate(width / 2, height / 2, 0);
  rotateX(mouseY * 0.01f);
  rotateY(mouseX * 0.01f);
  lights();
  shininess(16);
  directionalLight(255,255,255,0,-1,1);
  specular(255);
  drawAxes(400);
  if (isWireFrame) {
    noFill();
    stroke(255);
  } 
  else {
    fill(255);
    noStroke();
  }
  drawMesh(g, mesh, !isWireFrame, showNormals);
  
}

void drawAxes(float l) {
  stroke(255, 0, 0);
  line(0, 0, 0, l, 0, 0);
  stroke(0, 255, 0);
  line(0, 0, 0, 0, l, 0);
  stroke(0, 0, 255);
  line(0, 0, 0, 0, 0, l);
}

void drawMesh(PGraphics gfx, TriangleMesh mesh, boolean vertexNormals, boolean showNormals) {
  gfx.beginShape(PConstants.TRIANGLES);
  AABB bounds=mesh.getBoundingBox();
  Vec3D min=bounds.getMin();
  Vec3D max=bounds.getMax();
  if (vertexNormals) {
    for (Iterator i=mesh.faces.iterator(); i.hasNext();) {
      Face f=(Face)i.next();
      Vec3D n = normalMap.applyTo(f.a.normal);
      gfx.fill(n.x, n.y, n.z);
      gfx.normal(f.a.normal.x, f.a.normal.y, f.a.normal.z);
      gfx.vertex(f.a.x, f.a.y, f.a.z);
      n = normalMap.applyTo(f.b.normal);
      gfx.fill(n.x, n.y, n.z);
      gfx.normal(f.b.normal.x, f.b.normal.y, f.b.normal.z);
      gfx.vertex(f.b.x, f.b.y, f.b.z);
      n = normalMap.applyTo(f.c.normal);
      gfx.fill(n.x, n.y, n.z);
      gfx.normal(f.c.normal.x, f.c.normal.y, f.c.normal.z);
      gfx.vertex(f.c.x, f.c.y, f.c.z);
    }
  } 
  else {
    for (Iterator i=mesh.faces.iterator(); i.hasNext();) {
      Face f=(Face)i.next();
      gfx.normal(f.normal.x, f.normal.y, f.normal.z);
      gfx.vertex(f.a.x, f.a.y, f.a.z);
      gfx.vertex(f.b.x, f.b.y, f.b.z);
      gfx.vertex(f.c.x, f.c.y, f.c.z);
    }
  }
  gfx.endShape();
  if (showNormals) {
    if (vertexNormals) {
      for (Iterator i=mesh.vertices.values().iterator(); i.hasNext();) {
        Vertex v=(Vertex)i.next();
        Vec3D w = v.add(v.normal.scale(10));
        Vec3D n = v.normal.scale(127);
        gfx.stroke(n.x + 128, n.y + 128, n.z + 128);
        gfx.line(v.x, v.y, v.z, w.x, w.y, w.z);
      }
    } 
    else {
      for (Iterator i=mesh.faces.iterator(); i.hasNext();) {
        Face f=(Face)i.next();
        Vec3D c = f.a.add(f.b).addSelf(f.c).scaleSelf(1f / 3);
        Vec3D d = c.add(f.normal.scale(20));
        Vec3D n = f.normal.scale(127);
        gfx.stroke(n.x + 128, n.y + 128, n.z + 128);
        gfx.line(c.x, c.y, c.z, d.x, d.y, d.z);
      }
    }
  }
}

void keyPressed() {
  if (key == 'r') {
    randomizeMesh();
  }
  if (key == 'w') {
    isWireFrame = !isWireFrame;
  }
  if (key == 'n') {
    showNormals = !showNormals;
  }
  if (key == 's') {
    mesh.saveAsSTL(sketchPath("shape-"+i+".stl"));
  }
  
}

void randomizeMesh() {
  float[] m=new float[8];
  for(int i=0; i<8; i++) {
    m[i]=(int)random(9);
  }
  SurfaceMeshBuilder b = new SurfaceMeshBuilder(new SphericalHarmonics(m));
  mesh = (TriangleMesh)b.createMesh(null,80, 40);
}

/**
 * ControlP5basics

 * The following example demonstrates the basic use of controlP5.

 * After initializing controlP5 you can add controllers to controlP5.
 * Here we use three numberboxes, one slider and one textfield.
 * The numberbox with name numberboxC will trigger function numberboxC()
 * in the example below. Whenever controlP5 detects a function in your 
 * sketch that corresponds to the name of a controller, it will forward
 * an event to that function. Any event triggered by a controller 
 * will be forwarded to function controlEvent in your sketch. 

 * related examples ControlP5numberbox, ControlP5slider, ControlP5textfield

 * by Andreas Schlegel 2010

 * 
 */

import controlP5.*;

ControlP5 controlP5;

public int myColorRect = 200;

public int myColorBackground = 100;


void setup() {
  size(400,400);
  frameRate(25);
  controlP5 = new ControlP5(this);
  controlP5.addNumberbox("numberboxA",myColorRect,100,140,100,14).setId(1);
  controlP5.addNumberbox("numberboxB",myColorBackground,100,180,100,14).setId(2);
  controlP5.addNumberbox("numberboxC",0,100,220,100,14).setId(3);
  
  controlP5.addSlider("sliderA",100,200,100,100,260,100,14).setId(4);
  controlP5.addTextfield("textA",100,290,100,20).setId(5);
  
  controlP5.controller("numberboxA").setMax(255);
  controlP5.controller("numberboxA").setMin(0);
}

void draw() {
  background(myColorBackground);
  fill(myColorRect);
  rect(0,0,width,100);
}

public void numberboxC(int theValue) {
  println("### got an event from numberboxC : "+theValue);
}

// a slider event will change the value of textfield textA
public void sliderA(int theValue) {
  ((Textfield)controlP5.controller("textA")).setValue(""+theValue);
}

// for every change in textfield textA, this function will be called
public void textA(String theValue) {
  println("### got an event from textA : "+theValue);
}

public void controlEvent(ControlEvent theEvent) {
  println("got a control event from controller with id "+theEvent.controller().id());
  switch(theEvent.controller().id()) {
    case(1): // numberboxA
    myColorRect = (int)(theEvent.controller().value());
    break;
    case(2):  // numberboxB
    myColorBackground = (int)(theEvent.controller().value());
    break;  
  }

import shapes3d.utils.*;
import shapes3d.*;

import processing.opengl.*;
import unlekker.util.*;
import unlekker.modelbuilder.*;
import ec.util.*;
import unlekker.data.*;

int i=0;

Box box;
Ellipsoid sphere;

float a;

void setup() {
  size(200, 200, OPENGL);
  cursor(CROSS);
}

void draw() {
  float size=map(mouseX, 0, width, 10, width/8);
  //controls slices (north to south)
  int slices=10;
  
  //controls segments (east to west)
  int segments=(int)map(mouseY, 0, height, 10, height/2);

  box=new Box(this, size, size, size);
  box.moveTo(0, size, 0);
  box.fill(255);
  box.stroke(color(64, 0, 64));
  box.strokeWeight(1.2);
  box.drawMode(Shape3D.SOLID | Shape3D.WIRE);
  
  sphere=new Ellipsoid(this, slices, segments);
  sphere.setRadius(size);
  sphere.moveTo(0, -size/4, 0);
  sphere.fill(255);
  sphere.stroke(color(64, 0, 64));
  sphere.strokeWeight(1.2);
  sphere.drawMode(Shape3D.SOLID | Shape3D.WIRE);
  background(128);

  pushMatrix();
  
  camera(70 * sin(a), 10, 70 * cos(a), 0, 0, 0, 0, 1, 0);
  ambientLight(200, 200, 200);
  directionalLight(128, 128, 128, -1, 0, -1);

  box.draw();
  sphere.draw();

  popMatrix();

  a += 0.002;
}

void keyPressed() {
  if (key == 'e') {
    i++;
    beginRaw("unlekker.data.STL", "shape"+i+".stl");

    pushMatrix();
    camera(70 * sin(a), 10, 70 * cos(a), 0, 0, 0, 0, 1, 0);
    ambientLight(200, 200, 200);
    directionalLight(128, 128, 128, -1, 0, -1);

    box.draw();
    sphere.draw();

    popMatrix();
    endRaw();
  }
}

	import unlekker.mb2.geo.*;
import unlekker.mb2.util.*;
import unlekker.data.*;
import unlekker.mb2.externals.*;
import ec.util.*;

//based on "I Like Icosahedra" by Ira Greenberg. 


void setup() {
  size(400,400, P3D);
  
}
Icosahedron ico;

int rotX=0;
int i=0;

void draw() {
  ico = new Icosahedron(map(mouseX,0,width,10,100));
  background(0);
  lights();
  pushMatrix();
  translate(width/2, height/2, 0);
  rotateX(map(mouseX, 0,width, 0,PI));
  rotateY(map(mouseY, 0, height, 0, PI));
  stroke(150, 0, 180);
  fill(250, 100, 50);
  ico.create();
  popMatrix();
}


void keyPressed() {
  if (key == 'e') {
    i++;
    beginRaw("unlekker.data.STL","shape"+i+".stl");

    pushMatrix();
    rotateY(-PI/7.2);
    rotateX(PI/6.2);
    rotateZ(0);
    noStroke();

    ico.create();
    popMatrix();
     endRaw();
  } 
 
}
class Dimension3D {
  float w, h, d;

  Dimension3D(float w, float h, float d) {
    this.w=w;
    this.h=h;
    this.d=d;
  }
}




class Icosahedron extends Shape3D {

  // icosahedron
  PVector topPoint;
  PVector[] topPent = new PVector[5];
  PVector bottomPoint;
  PVector[] bottomPent = new PVector[5];
  float angle = 0, radius = 150;
  float triDist;
  float triHt;
  float a, b, c;

  // constructor
  Icosahedron(float radius) {
    this.radius = radius;
    init();
  }

  Icosahedron(PVector v, float radius) {
    super(v);
    this.radius = radius;
    init();
  }

  // calculate geometry
  void init() {
    c = dist(cos(0)*radius, sin(0)*radius, cos(radians(72))*radius,  sin(radians(72))*radius);
    b = radius;
    a = (float)(Math.sqrt(((c*c)-(b*b))));

    triHt = (float)(Math.sqrt((c*c)-((c/2)*(c/2))));

    for (int i=0; i<topPent.length; i++) {
      topPent[i] = new PVector(cos(angle)*radius, sin(angle)*radius, triHt/2.0f);
      angle+=radians(72);
    }
    topPoint = new PVector(0, 0, triHt/2.0f+a);
    angle = 72.0f/2.0f;
    for (int i=0; i<topPent.length; i++) {
      bottomPent[i] = new PVector(cos(angle)*radius, sin(angle)*radius, -triHt/2.0f);
      angle+=radians(72);
    }
    bottomPoint = new PVector(0, 0, -(triHt/2.0f+a));
  }

  // draws icosahedron 
  void create() {
    for (int i=0; i<topPent.length; i++) {
      // icosahedron top
      beginShape();
      if (i<topPent.length-1) {
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+topPoint.x, y+topPoint.y, z+topPoint.z);
        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
      } 
      else {
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+topPoint.x, y+topPoint.y, z+topPoint.z);
        vertex(x+topPent[0].x, y+topPent[0].y, z+topPent[0].z);
      }
      endShape(CLOSE);

      // icosahedron bottom
      beginShape();
      if (i<bottomPent.length-1) {
        vertex(x+bottomPent[i].x, y+bottomPent[i].y, z+bottomPent[i].z);
        vertex(x+bottomPoint.x, y+bottomPoint.y, z+bottomPoint.z);
        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
      } 
      else {
        vertex(x+bottomPent[i].x, y+bottomPent[i].y, z+bottomPent[i].z);
        vertex(x+bottomPoint.x, y+bottomPoint.y, z+bottomPoint.z);
        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
      }
      endShape(CLOSE);
    }

    // icosahedron body
    for (int i=0; i<topPent.length; i++) {
      if (i<topPent.length-2) {
        beginShape();
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
        vertex(x+bottomPent[i+2].x, y+bottomPent[i+2].y, z+bottomPent[i+2].z);
        endShape(CLOSE);

        beginShape();
        vertex(x+bottomPent[i+2].x, y+bottomPent[i+2].y, z+bottomPent[i+2].z);
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
        endShape(CLOSE);
      } 
      else if (i==topPent.length-2) {
        beginShape();
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
        endShape(CLOSE);

        beginShape();
        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
        endShape(CLOSE);
      }
      else if (i==topPent.length-1) {
        beginShape();
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
        vertex(x+bottomPent[1].x, y+bottomPent[1].y, z+bottomPent[1].z);
        endShape(CLOSE);

        beginShape();
        vertex(x+bottomPent[1].x, y+bottomPent[1].y, z+bottomPent[1].z);
        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
        vertex(x+topPent[0].x, y+topPent[0].y, z+topPent[0].z);
        endShape(CLOSE);
      }
    }
  }

  // overrided methods fom Shape3D
  void rotZ(float theta) {
    float tx=0, ty=0, tz=0;
    // top point
    tx = cos(theta)*topPoint.x+sin(theta)*topPoint.y;
    ty = sin(theta)*topPoint.x-cos(theta)*topPoint.y;
    topPoint.x = tx;
    topPoint.y = ty;

    // bottom point
    tx = cos(theta)*bottomPoint.x+sin(theta)*bottomPoint.y;
    ty = sin(theta)*bottomPoint.x-cos(theta)*bottomPoint.y;
    bottomPoint.x = tx;
    bottomPoint.y = ty;

    // top and bottom pentagons
    for (int i=0; i<topPent.length; i++) {
      tx = cos(theta)*topPent[i].x+sin(theta)*topPent[i].y;
      ty = sin(theta)*topPent[i].x-cos(theta)*topPent[i].y;
      topPent[i].x = tx;
      topPent[i].y = ty;

      tx = cos(theta)*bottomPent[i].x+sin(theta)*bottomPent[i].y;
      ty = sin(theta)*bottomPent[i].x-cos(theta)*bottomPent[i].y;
      bottomPent[i].x = tx;
      bottomPent[i].y = ty;
    }
  }

  void rotX(float theta) {
  }

  void rotY(float theta) {
  }
}




abstract class Shape3D {
  float x, y, z;
  float w, h, d;

  Shape3D() {
  }

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

  Shape3D(PVector p) {
    x = p.x;
    y = p.y;
    z = p.z;
  }


  Shape3D(Dimension3D dim) {
    w = dim.w;
    h = dim.h;
    d = dim.d;
  }

  Shape3D(float x, float y, float z, float w, float h, float d) {
    this.x = x;
    this.y = y;
    this.z = z;
    this.w = w;
    this.h = h;
    this.d = d;
  }

  Shape3D(float x, float y, float z, Dimension3D dim) {
    this.x = x;
    this.y = y;
    this.z = z;
    w = dim.w;
    h = dim.h;
    d = dim.d;
  }

  Shape3D(PVector p, Dimension3D dim) {
    x = p.x;
    y = p.y;
    z = p.z;
    w = dim.w;
    h = dim.h;
    d = dim.d;
  }

  void setLoc(PVector p) {
    x=p.x;
    y=p.y;
    z=p.z;
  }

  void setLoc(float x, float y, float z) {
    this.x=x;
    this.y=y;
    this.z=z;
  }


  // override if you need these
  void rotX(float theta) {
  }

  void rotY(float theta) {
  }

  void rotZ(float theta) {
  }


  // must be implemented in subclasses
  abstract void init();
  abstract void create();
}

/import processing.opengl.*;

import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.processing.*;

TriangleMesh mesh = new TriangleMesh();


ToxiclibsSupport gfx;
int i=0;

void setup() {
  size(400,400,OPENGL);
  gfx=new ToxiclibsSupport(this);
}


void draw() {
  background(51);
  lights();
  translate(width / 2, height / 2, 0);
  rotateX(mouseY * 0.01f);
  noStroke();
  Vec3D BOX_SIZE = new Vec3D(mouseX/2,mouseY/2,mouseX/2);
  TriangleMesh b=(TriangleMesh)new AABB(new Vec3D(), BOX_SIZE).toMesh();
  gfx.mesh(b);
}


void keyPressed() {
  i++;
  if (key == 's') {
    mesh.saveAsSTL(sketchPath("cube"+i+".stl"));
  }
}

/import processing.opengl.*;

import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.processing.*;

TriangleMesh mesh = new TriangleMesh();


ToxiclibsSupport gfx;
int i=0;

void setup() {
  size(400,400,OPENGL);
  gfx=new ToxiclibsSupport(this);
}


void draw() {
  background(51);
  lights();
  translate(width / 2, height / 2, 0);
  rotateX(mouseY * 0.01f);
  noStroke();
  Vec3D BOX_SIZE = new Vec3D(mouseX/2,mouseY/2,mouseX/2);
  TriangleMesh b=(TriangleMesh)new AABB(new Vec3D(), BOX_SIZE).toMesh();
  gfx.mesh(b);
}


void keyPressed() {
  i++;
  if (key == 's') {
    mesh.saveAsSTL(sketchPath("cube"+i+".stl"));
  }
}