@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Brick Tower
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* 3D castle tower constructed out of individual bricks.
|
||||
* Uses the PVector and Cube classes.
|
||||
*/
|
||||
|
||||
float bricksPerLayer = 16.0;
|
||||
float brickLayers = 18.0;
|
||||
Cube brick;
|
||||
float brickWidth = 60, brickHeight = 25, brickDepth = 25;
|
||||
float radius = 175.0;
|
||||
float angle = 0;
|
||||
|
||||
void setup(){
|
||||
size(640, 360, P3D);
|
||||
brick = new Cube(brickWidth, brickHeight, brickDepth);
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(0);
|
||||
float tempX = 0, tempY = 0, tempZ = 0;
|
||||
fill(182, 62, 29);
|
||||
noStroke();
|
||||
// Add basic light setup
|
||||
lights();
|
||||
translate(width/2, height*1.2, -380);
|
||||
// Tip tower to see inside
|
||||
rotateX(radians(-45));
|
||||
// Slowly rotate tower
|
||||
rotateY(frameCount * PI/600);
|
||||
for (int i = 0; i < brickLayers; i++){
|
||||
// Increment rows
|
||||
tempY-=brickHeight;
|
||||
// Alternate brick seams
|
||||
angle = 360.0 / bricksPerLayer * i/2;
|
||||
for (int j = 0; j < bricksPerLayer; j++){
|
||||
tempZ = cos(radians(angle))*radius;
|
||||
tempX = sin(radians(angle))*radius;
|
||||
pushMatrix();
|
||||
translate(tempX, tempY, tempZ);
|
||||
rotateY(radians(angle));
|
||||
// Add crenelation
|
||||
if (i==brickLayers-1){
|
||||
if (j%2 == 0){
|
||||
brick.create();
|
||||
}
|
||||
}
|
||||
// Create main tower
|
||||
else {
|
||||
brick.create();
|
||||
}
|
||||
popMatrix();
|
||||
angle += 360.0/bricksPerLayer;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
class Cube {
|
||||
|
||||
PVector[] vertices = new PVector[24];
|
||||
float w, h, d;
|
||||
|
||||
Cube(){ }
|
||||
|
||||
Cube(float w, float h, float d){
|
||||
this.w = w;
|
||||
this.h = h;
|
||||
this.d = d;
|
||||
|
||||
// Cube composed of 6 quads
|
||||
// Front
|
||||
vertices[0] = new PVector(-w/2, -h/2, d/2);
|
||||
vertices[1] = new PVector(w/2, -h/2, d/2);
|
||||
vertices[2] = new PVector(w/2, h/2, d/2);
|
||||
vertices[3] = new PVector(-w/2, h/2, d/2);
|
||||
|
||||
// Left
|
||||
vertices[4] = new PVector(-w/2, -h/2, d/2);
|
||||
vertices[5] = new PVector(-w/2, -h/2, -d/2);
|
||||
vertices[6] = new PVector(-w/2, h/2, -d/2);
|
||||
vertices[7] = new PVector(-w/2, h/2, d/2);
|
||||
|
||||
// Right
|
||||
vertices[8] = new PVector(w/2, -h/2, d/2);
|
||||
vertices[9] = new PVector(w/2, -h/2, -d/2);
|
||||
vertices[10] = new PVector(w/2, h/2, -d/2);
|
||||
vertices[11] = new PVector(w/2, h/2, d/2);
|
||||
|
||||
// Back
|
||||
vertices[12] = new PVector(-w/2, -h/2, -d/2);
|
||||
vertices[13] = new PVector(w/2, -h/2, -d/2);
|
||||
vertices[14] = new PVector(w/2, h/2, -d/2);
|
||||
vertices[15] = new PVector(-w/2, h/2, -d/2);
|
||||
|
||||
// Top
|
||||
vertices[16] = new PVector(-w/2, -h/2, d/2);
|
||||
vertices[17] = new PVector(-w/2, -h/2, -d/2);
|
||||
vertices[18] = new PVector(w/2, -h/2, -d/2);
|
||||
vertices[19] = new PVector(w/2, -h/2, d/2);
|
||||
|
||||
// Bottom
|
||||
vertices[20] = new PVector(-w/2, h/2, d/2);
|
||||
vertices[21] = new PVector(-w/2, h/2, -d/2);
|
||||
vertices[22] = new PVector(w/2, h/2, -d/2);
|
||||
vertices[23] = new PVector(w/2, h/2, d/2);
|
||||
}
|
||||
|
||||
void create(){
|
||||
for (int i=0; i<6; i++){
|
||||
beginShape(QUADS);
|
||||
for (int j = 0; j < 4; j++){
|
||||
vertex(vertices[j+4*i].x, vertices[j+4*i].y, vertices[j+4*i].z);
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class BrickTower extends PApplet {
|
||||
|
||||
/**
|
||||
* Brick Tower
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* 3D castle tower constructed out of individual bricks.
|
||||
* Uses the Point3D and Cube classes.
|
||||
*/
|
||||
|
||||
|
||||
float bricksPerLayer = 16.0f;
|
||||
float brickLayers = 18.0f;
|
||||
Cube brick;
|
||||
float brickWidth = 60, brickHeight = 25, brickDepth = 25;
|
||||
float radius = 175.0f;
|
||||
float angle = 0;
|
||||
|
||||
public void setup(){
|
||||
size(640, 360, P3D);
|
||||
brick = new Cube(brickWidth, brickHeight, brickDepth);
|
||||
}
|
||||
|
||||
public void draw(){
|
||||
background(0);
|
||||
float tempX = 0, tempY = 0, tempZ = 0;
|
||||
fill(182, 62, 29);
|
||||
noStroke();
|
||||
// Add basic light setup
|
||||
lights();
|
||||
translate(width/2, height*1.2f, -380);
|
||||
// Tip tower to see inside
|
||||
rotateX(radians(-45));
|
||||
// Slowly rotate tower
|
||||
rotateY(frameCount * PI/600);
|
||||
for (int i = 0; i < brickLayers; i++){
|
||||
// Increment rows
|
||||
tempY-=brickHeight;
|
||||
// Alternate brick seams
|
||||
angle = 360.0f / bricksPerLayer * i/2;
|
||||
for (int j = 0; j < bricksPerLayer; j++){
|
||||
tempZ = cos(radians(angle))*radius;
|
||||
tempX = sin(radians(angle))*radius;
|
||||
pushMatrix();
|
||||
translate(tempX, tempY, tempZ);
|
||||
rotateY(radians(angle));
|
||||
// Add crenelation
|
||||
if (i==brickLayers-1){
|
||||
if (j%2 == 0){
|
||||
brick.create();
|
||||
}
|
||||
}
|
||||
// Create main tower
|
||||
else {
|
||||
brick.create();
|
||||
}
|
||||
popMatrix();
|
||||
angle += 360.0f/bricksPerLayer;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class Cube {
|
||||
|
||||
Point3D[] vertices = new Point3D[24];
|
||||
float w, h, d;
|
||||
|
||||
Cube(){ }
|
||||
|
||||
Cube(float w, float h, float d){
|
||||
this.w = w;
|
||||
this.h = h;
|
||||
this.d = d;
|
||||
|
||||
// Cube composed of 6 quads
|
||||
// Front
|
||||
vertices[0] = new Point3D(-w/2,-h/2,d/2);
|
||||
vertices[1] = new Point3D(w/2,-h/2,d/2);
|
||||
vertices[2] = new Point3D(w/2,h/2,d/2);
|
||||
vertices[3] = new Point3D(-w/2,h/2,d/2);
|
||||
|
||||
// Left
|
||||
vertices[4] = new Point3D(-w/2,-h/2,d/2);
|
||||
vertices[5] = new Point3D(-w/2,-h/2,-d/2);
|
||||
vertices[6] = new Point3D(-w/2,h/2,-d/2);
|
||||
vertices[7] = new Point3D(-w/2,h/2,d/2);
|
||||
|
||||
// Right
|
||||
vertices[8] = new Point3D(w/2,-h/2,d/2);
|
||||
vertices[9] = new Point3D(w/2,-h/2,-d/2);
|
||||
vertices[10] = new Point3D(w/2,h/2,-d/2);
|
||||
vertices[11] = new Point3D(w/2,h/2,d/2);
|
||||
|
||||
// Back
|
||||
vertices[12] = new Point3D(-w/2,-h/2,-d/2);
|
||||
vertices[13] = new Point3D(w/2,-h/2,-d/2);
|
||||
vertices[14] = new Point3D(w/2,h/2,-d/2);
|
||||
vertices[15] = new Point3D(-w/2,h/2,-d/2);
|
||||
|
||||
// Top
|
||||
vertices[16] = new Point3D(-w/2,-h/2,d/2);
|
||||
vertices[17] = new Point3D(-w/2,-h/2,-d/2);
|
||||
vertices[18] = new Point3D(w/2,-h/2,-d/2);
|
||||
vertices[19] = new Point3D(w/2,-h/2,d/2);
|
||||
|
||||
// Bottom
|
||||
vertices[20] = new Point3D(-w/2,h/2,d/2);
|
||||
vertices[21] = new Point3D(-w/2,h/2,-d/2);
|
||||
vertices[22] = new Point3D(w/2,h/2,-d/2);
|
||||
vertices[23] = new Point3D(w/2,h/2,d/2);
|
||||
}
|
||||
|
||||
public void create(){
|
||||
for (int i=0; i<6; i++){
|
||||
beginShape(QUADS);
|
||||
for (int j = 0; j < 4; j++){
|
||||
vertex(vertices[j+4*i].x, vertices[j+4*i].y, vertices[j+4*i].z);
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
}
|
||||
class Point3D {
|
||||
float x, y, z;
|
||||
|
||||
Point3D(){ }
|
||||
|
||||
Point3D(float x, float y, float z){
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
}
|
||||
}
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "BrickTower" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Brick Tower
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* 3D castle tower constructed out of individual bricks.
|
||||
* Uses the Point3D and Cube classes.
|
||||
*/
|
||||
|
||||
|
||||
float bricksPerLayer = 16.0;
|
||||
float brickLayers = 18.0;
|
||||
Cube brick;
|
||||
float brickWidth = 60, brickHeight = 25, brickDepth = 25;
|
||||
float radius = 175.0;
|
||||
float angle = 0;
|
||||
|
||||
void setup(){
|
||||
size(640, 360, P3D);
|
||||
brick = new Cube(brickWidth, brickHeight, brickDepth);
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(0);
|
||||
float tempX = 0, tempY = 0, tempZ = 0;
|
||||
fill(182, 62, 29);
|
||||
noStroke();
|
||||
// Add basic light setup
|
||||
lights();
|
||||
translate(width/2, height*1.2, -380);
|
||||
// Tip tower to see inside
|
||||
rotateX(radians(-45));
|
||||
// Slowly rotate tower
|
||||
rotateY(frameCount * PI/600);
|
||||
for (int i = 0; i < brickLayers; i++){
|
||||
// Increment rows
|
||||
tempY-=brickHeight;
|
||||
// Alternate brick seams
|
||||
angle = 360.0 / bricksPerLayer * i/2;
|
||||
for (int j = 0; j < bricksPerLayer; j++){
|
||||
tempZ = cos(radians(angle))*radius;
|
||||
tempX = sin(radians(angle))*radius;
|
||||
pushMatrix();
|
||||
translate(tempX, tempY, tempZ);
|
||||
rotateY(radians(angle));
|
||||
// Add crenelation
|
||||
if (i==brickLayers-1){
|
||||
if (j%2 == 0){
|
||||
brick.create();
|
||||
}
|
||||
}
|
||||
// Create main tower
|
||||
else {
|
||||
brick.create();
|
||||
}
|
||||
popMatrix();
|
||||
angle += 360.0/bricksPerLayer;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
class Cube {
|
||||
|
||||
Point3D[] vertices = new Point3D[24];
|
||||
float w, h, d;
|
||||
|
||||
Cube(){ }
|
||||
|
||||
Cube(float w, float h, float d){
|
||||
this.w = w;
|
||||
this.h = h;
|
||||
this.d = d;
|
||||
|
||||
// Cube composed of 6 quads
|
||||
// Front
|
||||
vertices[0] = new Point3D(-w/2,-h/2,d/2);
|
||||
vertices[1] = new Point3D(w/2,-h/2,d/2);
|
||||
vertices[2] = new Point3D(w/2,h/2,d/2);
|
||||
vertices[3] = new Point3D(-w/2,h/2,d/2);
|
||||
|
||||
// Left
|
||||
vertices[4] = new Point3D(-w/2,-h/2,d/2);
|
||||
vertices[5] = new Point3D(-w/2,-h/2,-d/2);
|
||||
vertices[6] = new Point3D(-w/2,h/2,-d/2);
|
||||
vertices[7] = new Point3D(-w/2,h/2,d/2);
|
||||
|
||||
// Right
|
||||
vertices[8] = new Point3D(w/2,-h/2,d/2);
|
||||
vertices[9] = new Point3D(w/2,-h/2,-d/2);
|
||||
vertices[10] = new Point3D(w/2,h/2,-d/2);
|
||||
vertices[11] = new Point3D(w/2,h/2,d/2);
|
||||
|
||||
// Back
|
||||
vertices[12] = new Point3D(-w/2,-h/2,-d/2);
|
||||
vertices[13] = new Point3D(w/2,-h/2,-d/2);
|
||||
vertices[14] = new Point3D(w/2,h/2,-d/2);
|
||||
vertices[15] = new Point3D(-w/2,h/2,-d/2);
|
||||
|
||||
// Top
|
||||
vertices[16] = new Point3D(-w/2,-h/2,d/2);
|
||||
vertices[17] = new Point3D(-w/2,-h/2,-d/2);
|
||||
vertices[18] = new Point3D(w/2,-h/2,-d/2);
|
||||
vertices[19] = new Point3D(w/2,-h/2,d/2);
|
||||
|
||||
// Bottom
|
||||
vertices[20] = new Point3D(-w/2,h/2,d/2);
|
||||
vertices[21] = new Point3D(-w/2,h/2,-d/2);
|
||||
vertices[22] = new Point3D(w/2,h/2,-d/2);
|
||||
vertices[23] = new Point3D(w/2,h/2,d/2);
|
||||
}
|
||||
|
||||
void create(){
|
||||
for (int i=0; i<6; i++){
|
||||
beginShape(QUADS);
|
||||
for (int j = 0; j < 4; j++){
|
||||
vertex(vertices[j+4*i].x, vertices[j+4*i].y, vertices[j+4*i].z);
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* Cubic Grid
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* 3D translucent colored grid uses nested pushMatrix()
|
||||
* and popMatrix() functions.
|
||||
*/
|
||||
|
||||
float boxSize = 40;
|
||||
float margin = boxSize*2;
|
||||
float depth = 400;
|
||||
color boxFill;
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(255);
|
||||
|
||||
// Center and spin grid
|
||||
translate(width/2, height/2, -depth);
|
||||
rotateY(frameCount * 0.01);
|
||||
rotateX(frameCount * 0.01);
|
||||
|
||||
// Build grid using multiple translations
|
||||
for (float i =- depth/2+margin; i <= depth/2-margin; i += boxSize){
|
||||
pushMatrix();
|
||||
for (float j =- height+margin; j <= height-margin; j += boxSize){
|
||||
pushMatrix();
|
||||
for (float k =- width+margin; k <= width-margin; k += boxSize){
|
||||
// Base fill color on counter values, abs function
|
||||
// ensures values stay within legal range
|
||||
boxFill = color(abs(i), abs(j), abs(k), 50);
|
||||
pushMatrix();
|
||||
translate(k, j, i);
|
||||
fill(boxFill);
|
||||
box(boxSize, boxSize, boxSize);
|
||||
popMatrix();
|
||||
}
|
||||
popMatrix();
|
||||
}
|
||||
popMatrix();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class CubicGrid extends PApplet {
|
||||
|
||||
/**
|
||||
* Cubic Grid
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* 3D translucent colored grid uses nested pushMatrix()
|
||||
* and popMatrix() functions.
|
||||
*/
|
||||
|
||||
float boxSize = 40;
|
||||
float margin = boxSize*2;
|
||||
float depth = 400;
|
||||
int boxFill;
|
||||
|
||||
public void setup() {
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
background(255);
|
||||
|
||||
// Center and spin grid
|
||||
translate(width/2, height/2, -depth);
|
||||
rotateY(frameCount * 0.01f);
|
||||
rotateX(frameCount * 0.01f);
|
||||
|
||||
// Build grid using multiple translations
|
||||
for (float i =- depth/2+margin; i <= depth/2-margin; i += boxSize){
|
||||
pushMatrix();
|
||||
for (float j =- height+margin; j <= height-margin; j += boxSize){
|
||||
pushMatrix();
|
||||
for (float k =- width+margin; k <= width-margin; k += boxSize){
|
||||
// Base fill color on counter values, abs function
|
||||
// ensures values stay within legal range
|
||||
boxFill = color(abs(i), abs(j), abs(k), 50);
|
||||
pushMatrix();
|
||||
translate(k, j, i);
|
||||
fill(boxFill);
|
||||
box(boxSize, boxSize, boxSize);
|
||||
popMatrix();
|
||||
}
|
||||
popMatrix();
|
||||
}
|
||||
popMatrix();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "CubicGrid" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* Cubic Grid
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* 3D translucent colored grid uses nested pushMatrix()
|
||||
* and popMatrix() functions.
|
||||
*/
|
||||
|
||||
float boxSize = 40;
|
||||
float margin = boxSize*2;
|
||||
float depth = 400;
|
||||
color boxFill;
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(255);
|
||||
|
||||
// Center and spin grid
|
||||
translate(width/2, height/2, -depth);
|
||||
rotateY(frameCount * 0.01);
|
||||
rotateX(frameCount * 0.01);
|
||||
|
||||
// Build grid using multiple translations
|
||||
for (float i =- depth/2+margin; i <= depth/2-margin; i += boxSize){
|
||||
pushMatrix();
|
||||
for (float j =- height+margin; j <= height-margin; j += boxSize){
|
||||
pushMatrix();
|
||||
for (float k =- width+margin; k <= width-margin; k += boxSize){
|
||||
// Base fill color on counter values, abs function
|
||||
// ensures values stay within legal range
|
||||
boxFill = color(abs(i), abs(j), abs(k), 50);
|
||||
pushMatrix();
|
||||
translate(k, j, i);
|
||||
fill(boxFill);
|
||||
box(boxSize, boxSize, boxSize);
|
||||
popMatrix();
|
||||
}
|
||||
popMatrix();
|
||||
}
|
||||
popMatrix();
|
||||
}
|
||||
}
|
||||
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,10 @@
|
||||
class Dimension3D{
|
||||
float w, h, d;
|
||||
|
||||
Dimension3D(float w, float h, float d){
|
||||
this.w=w;
|
||||
this.h=h;
|
||||
this.d=d;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* I Like Icosahedra
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* This example plots icosahedra. The Icosahdron is a regular
|
||||
* polyhedron composed of twenty equalateral triangles.
|
||||
*/
|
||||
|
||||
Icosahedron ico1;
|
||||
Icosahedron ico2;
|
||||
Icosahedron ico3;
|
||||
|
||||
void setup(){
|
||||
size(640, 360, P3D);
|
||||
ico1 = new Icosahedron(75);
|
||||
ico2 = new Icosahedron(75);
|
||||
ico3 = new Icosahedron(75);
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(0);
|
||||
lights();
|
||||
translate(width/2, height/2);
|
||||
|
||||
pushMatrix();
|
||||
translate(-width/3.5, 0);
|
||||
rotateX(frameCount*PI/185);
|
||||
rotateY(frameCount*PI/-200);
|
||||
stroke(170, 0, 0);
|
||||
noFill();
|
||||
ico1.create();
|
||||
popMatrix();
|
||||
|
||||
pushMatrix();
|
||||
rotateX(frameCount*PI/200);
|
||||
rotateY(frameCount*PI/300);
|
||||
stroke(150, 0, 180);
|
||||
fill(170, 170, 0);
|
||||
ico2.create();
|
||||
popMatrix();
|
||||
|
||||
pushMatrix();
|
||||
translate(width/3.5, 0);
|
||||
rotateX(frameCount*PI/-200);
|
||||
rotateY(frameCount*PI/200);
|
||||
noStroke();
|
||||
fill(0, 0, 185);
|
||||
ico3.create();
|
||||
popMatrix();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,159 @@
|
||||
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){
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
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();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
class Dimension3D {
|
||||
|
||||
float w, h, d;
|
||||
|
||||
Dimension3D(float w, float h, float d){
|
||||
this.w=w;
|
||||
this.h=h;
|
||||
this.d=d;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,416 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class Icosahedra extends PApplet {
|
||||
|
||||
/**
|
||||
* I Like Icosahedra
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* This example plots icosahedra. The Icosahdron is a regular
|
||||
* polyhedron composed of 20 equalateral triangles.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
Icosahedron ico1;
|
||||
Icosahedron ico2;
|
||||
Icosahedron ico3;
|
||||
|
||||
public void setup() {
|
||||
size(640, 360, P3D);
|
||||
ico1 = new Icosahedron(75);
|
||||
ico2 = new Icosahedron(75);
|
||||
ico3 = new Icosahedron(75);
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
background(0);
|
||||
lights();
|
||||
translate(width/2, height/2);
|
||||
|
||||
pushMatrix();
|
||||
translate(-width/3.5f, 0);
|
||||
rotateX(frameCount * PI/185);
|
||||
rotateY(frameCount * PI/-200);
|
||||
stroke(170, 0, 0);
|
||||
noFill();
|
||||
ico1.create();
|
||||
popMatrix();
|
||||
|
||||
pushMatrix();
|
||||
rotateX(frameCount * PI/200);
|
||||
rotateY(frameCount * PI/300);
|
||||
stroke(150, 0, 180);
|
||||
fill(170, 170, 0);
|
||||
ico2.create();
|
||||
popMatrix();
|
||||
|
||||
pushMatrix();
|
||||
translate(width/3.5f, 0);
|
||||
rotateX(frameCount * PI/-200);
|
||||
rotateY(frameCount * PI/200);
|
||||
noStroke();
|
||||
fill(0, 0, 185);
|
||||
ico3.create();
|
||||
popMatrix();
|
||||
}
|
||||
|
||||
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
|
||||
Vector3D topPoint;
|
||||
Vector3D[] topPent = new Vector3D[5];
|
||||
Vector3D bottomPoint;
|
||||
Vector3D[] bottomPent = new Vector3D[5];
|
||||
float angle = 0, radius = 150;
|
||||
float triDist;
|
||||
float triHt;
|
||||
float a, b, c;
|
||||
|
||||
// constructor
|
||||
Icosahedron(float radius) {
|
||||
this.radius = radius;
|
||||
init();
|
||||
}
|
||||
|
||||
Icosahedron(Vector3D v, float radius) {
|
||||
super(v);
|
||||
this.radius = radius;
|
||||
init();
|
||||
}
|
||||
|
||||
// calculate geometry
|
||||
public 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 Vector3D(cos(angle)*radius,
|
||||
sin(angle)*radius, triHt/2.0f);
|
||||
angle+=radians(72);
|
||||
}
|
||||
topPoint = new Vector3D(0, 0, triHt/2.0f+a);
|
||||
angle = 72.0f/2.0f;
|
||||
for (int i = 0; i < topPent.length; i++){
|
||||
bottomPent[i] = new Vector3D(cos(angle)*radius,
|
||||
sin(angle)*radius, -triHt/2.0f);
|
||||
angle+=radians(72);
|
||||
}
|
||||
bottomPoint = new Vector3D(0, 0, -(triHt/2.0f+a));
|
||||
}
|
||||
|
||||
// draws icosahedron
|
||||
public 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
|
||||
public 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;
|
||||
}
|
||||
}
|
||||
|
||||
public void rotX(float theta){
|
||||
}
|
||||
|
||||
public 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(Vector3D 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(Vector3D p, Dimension3D dim) {
|
||||
x = p.x;
|
||||
y = p.y;
|
||||
z = p.z;
|
||||
w = dim.w;
|
||||
h = dim.h;
|
||||
d = dim.d;
|
||||
}
|
||||
|
||||
public void setLoc(Vector3D p) {
|
||||
x=p.x;
|
||||
y=p.y;
|
||||
z=p.z;
|
||||
}
|
||||
|
||||
public void setLoc(float x, float y, float z) {
|
||||
this.x=x;
|
||||
this.y=y;
|
||||
this.z=z;
|
||||
}
|
||||
|
||||
|
||||
// override if you need these
|
||||
public void rotX(float theta) {
|
||||
}
|
||||
|
||||
public void rotY(float theta) {
|
||||
}
|
||||
|
||||
public void rotZ(float theta) {
|
||||
}
|
||||
|
||||
|
||||
// must be implemented in subclasses
|
||||
public abstract void init();
|
||||
public abstract void create();
|
||||
}
|
||||
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
|
||||
public void add(Vector3D v) {
|
||||
x+=v.x;
|
||||
y+=v.y;
|
||||
z+=v.z;
|
||||
}
|
||||
|
||||
public void subtract(Vector3D v) {
|
||||
x-=v.x;
|
||||
y-=v.y;
|
||||
z-=v.z;
|
||||
}
|
||||
|
||||
public void multiply(float s) {
|
||||
x*=s;
|
||||
y*=s;
|
||||
z*=s;
|
||||
}
|
||||
|
||||
public void divide(float s) {
|
||||
x/=s;
|
||||
y/=s;
|
||||
z/=s;
|
||||
}
|
||||
|
||||
public 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;
|
||||
}
|
||||
|
||||
public void setTo(Vector3D v) {
|
||||
x = v.x;
|
||||
y = v.y;
|
||||
z = v.z;
|
||||
}
|
||||
|
||||
public void reset() {
|
||||
x = origVals[0];
|
||||
y = origVals[1];
|
||||
z = origVals[2];
|
||||
}
|
||||
|
||||
public float getDotProduct(Vector3D v) {
|
||||
return x*v.x + y*v.y + z*v.z;
|
||||
}
|
||||
|
||||
public 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);
|
||||
}
|
||||
|
||||
public Vector3D getNormal(Vector3D v, Vector3D u) {
|
||||
Vector3D n = getCrossProduct(v, u);
|
||||
n.normalize();
|
||||
return(n);
|
||||
}
|
||||
|
||||
public void normalize() {
|
||||
float m = getMagnitude();
|
||||
x/=m;
|
||||
y/=m;
|
||||
z/=m;
|
||||
}
|
||||
|
||||
public float getMagnitude() {
|
||||
return sqrt(x*x+y*y+z*z);
|
||||
}
|
||||
}
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "Icosahedra" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
/**
|
||||
* I Like Icosahedra
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* This example plots icosahedra. The Icosahdron is a regular
|
||||
* polyhedron composed of 20 equalateral triangles.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
Icosahedron ico1;
|
||||
Icosahedron ico2;
|
||||
Icosahedron ico3;
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
ico1 = new Icosahedron(75);
|
||||
ico2 = new Icosahedron(75);
|
||||
ico3 = new Icosahedron(75);
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(0);
|
||||
lights();
|
||||
translate(width/2, height/2);
|
||||
|
||||
pushMatrix();
|
||||
translate(-width/3.5, 0);
|
||||
rotateX(frameCount * PI/185);
|
||||
rotateY(frameCount * PI/-200);
|
||||
stroke(170, 0, 0);
|
||||
noFill();
|
||||
ico1.create();
|
||||
popMatrix();
|
||||
|
||||
pushMatrix();
|
||||
rotateX(frameCount * PI/200);
|
||||
rotateY(frameCount * PI/300);
|
||||
stroke(150, 0, 180);
|
||||
fill(170, 170, 0);
|
||||
ico2.create();
|
||||
popMatrix();
|
||||
|
||||
pushMatrix();
|
||||
translate(width/3.5, 0);
|
||||
rotateX(frameCount * PI/-200);
|
||||
rotateY(frameCount * PI/200);
|
||||
noStroke();
|
||||
fill(0, 0, 185);
|
||||
ico3.create();
|
||||
popMatrix();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
class Icosahedron extends Shape3D {
|
||||
|
||||
// icosahedron
|
||||
Vector3D topPoint;
|
||||
Vector3D[] topPent = new Vector3D[5];
|
||||
Vector3D bottomPoint;
|
||||
Vector3D[] bottomPent = new Vector3D[5];
|
||||
float angle = 0, radius = 150;
|
||||
float triDist;
|
||||
float triHt;
|
||||
float a, b, c;
|
||||
|
||||
// constructor
|
||||
Icosahedron(float radius) {
|
||||
this.radius = radius;
|
||||
init();
|
||||
}
|
||||
|
||||
Icosahedron(Vector3D 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 Vector3D(cos(angle)*radius,
|
||||
sin(angle)*radius, triHt/2.0);
|
||||
angle+=radians(72);
|
||||
}
|
||||
topPoint = new Vector3D(0, 0, triHt/2.0+a);
|
||||
angle = 72.0/2.0;
|
||||
for (int i = 0; i < topPent.length; i++){
|
||||
bottomPent[i] = new Vector3D(cos(angle)*radius,
|
||||
sin(angle)*radius, -triHt/2.0);
|
||||
angle+=radians(72);
|
||||
}
|
||||
bottomPoint = new Vector3D(0, 0, -(triHt/2.0+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){
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
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(Vector3D 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(Vector3D p, Dimension3D dim) {
|
||||
x = p.x;
|
||||
y = p.y;
|
||||
z = p.z;
|
||||
w = dim.w;
|
||||
h = dim.h;
|
||||
d = dim.d;
|
||||
}
|
||||
|
||||
void setLoc(Vector3D 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();
|
||||
}
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* Primitives 3D.
|
||||
*
|
||||
* Placing mathematically 3D objects in synthetic space.
|
||||
* The lights() method reveals their imagined dimension.
|
||||
* The box() and sphere() functions each have one parameter
|
||||
* which is used to specify their size. These shapes are
|
||||
* positioned using the translate() function.
|
||||
*/
|
||||
|
||||
size(640, 360, P3D);
|
||||
background(0);
|
||||
lights();
|
||||
|
||||
noStroke();
|
||||
pushMatrix();
|
||||
translate(130, height/2, 0);
|
||||
rotateY(1.25);
|
||||
rotateX(-0.4);
|
||||
box(100);
|
||||
popMatrix();
|
||||
|
||||
noFill();
|
||||
stroke(255);
|
||||
pushMatrix();
|
||||
translate(500, height*0.35, -200);
|
||||
sphere(280);
|
||||
popMatrix();
|
||||
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class Primitives3D extends PApplet {
|
||||
public void setup() {/**
|
||||
* Primitives 3D.
|
||||
*
|
||||
* Placing mathematically 3D objects in synthetic space.
|
||||
* The lights() method reveals their imagined dimension.
|
||||
* The box() and sphere() functions each have one parameter
|
||||
* which is used to specify their size. These shapes are
|
||||
* positioned using the translate() function.
|
||||
*/
|
||||
|
||||
size(640, 360, P3D);
|
||||
background(0);
|
||||
lights();
|
||||
|
||||
noStroke();
|
||||
pushMatrix();
|
||||
translate(130, height/2, 0);
|
||||
rotateY(1.25f);
|
||||
rotateX(-0.4f);
|
||||
box(100);
|
||||
popMatrix();
|
||||
|
||||
noFill();
|
||||
stroke(255);
|
||||
pushMatrix();
|
||||
translate(500, height*0.35f, -200);
|
||||
sphere(280);
|
||||
popMatrix();
|
||||
|
||||
|
||||
|
||||
noLoop();
|
||||
}
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "Primitives3D" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* Primitives 3D.
|
||||
*
|
||||
* Placing mathematically 3D objects in synthetic space.
|
||||
* The lights() method reveals their imagined dimension.
|
||||
* The box() and sphere() functions each have one parameter
|
||||
* which is used to specify their size. These shapes are
|
||||
* positioned using the translate() function.
|
||||
*/
|
||||
|
||||
size(640, 360, P3D);
|
||||
background(0);
|
||||
lights();
|
||||
|
||||
noStroke();
|
||||
pushMatrix();
|
||||
translate(130, height/2, 0);
|
||||
rotateY(1.25);
|
||||
rotateX(-0.4);
|
||||
box(100);
|
||||
popMatrix();
|
||||
|
||||
noFill();
|
||||
stroke(255);
|
||||
pushMatrix();
|
||||
translate(500, height*0.35, -200);
|
||||
sphere(280);
|
||||
popMatrix();
|
||||
|
||||
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,74 @@
|
||||
/**
|
||||
* RGB Cube.
|
||||
*
|
||||
* The three primary colors of the additive color model are red, green, and blue.
|
||||
* This RGB color cube displays smooth transitions between these colors.
|
||||
*/
|
||||
|
||||
float xmag, ymag = 0;
|
||||
float newXmag, newYmag = 0;
|
||||
|
||||
void setup()
|
||||
{
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
colorMode(RGB, 1);
|
||||
}
|
||||
|
||||
void draw()
|
||||
{
|
||||
background(0.5);
|
||||
|
||||
pushMatrix();
|
||||
|
||||
translate(width/2, height/2, -30);
|
||||
|
||||
newXmag = mouseX/float(width) * TWO_PI;
|
||||
newYmag = mouseY/float(height) * TWO_PI;
|
||||
|
||||
float diff = xmag-newXmag;
|
||||
if (abs(diff) > 0.01) { xmag -= diff/4.0; }
|
||||
|
||||
diff = ymag-newYmag;
|
||||
if (abs(diff) > 0.01) { ymag -= diff/4.0; }
|
||||
|
||||
rotateX(-ymag);
|
||||
rotateY(-xmag);
|
||||
|
||||
scale(90);
|
||||
beginShape(QUADS);
|
||||
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
|
||||
endShape();
|
||||
|
||||
popMatrix();
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class RGBCube extends PApplet {
|
||||
|
||||
/**
|
||||
* RGB Cube.
|
||||
*
|
||||
* The three primary colors of the additive color model are red, green, and blue.
|
||||
* This RGB color cube displays smooth transitions between these colors.
|
||||
*/
|
||||
|
||||
float xmag, ymag = 0;
|
||||
float newXmag, newYmag = 0;
|
||||
|
||||
public void setup()
|
||||
{
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
colorMode(RGB, 1);
|
||||
}
|
||||
|
||||
public void draw()
|
||||
{
|
||||
background(0.5f);
|
||||
|
||||
pushMatrix();
|
||||
|
||||
translate(width/2, height/2, -30);
|
||||
|
||||
newXmag = mouseX/PApplet.parseFloat(width) * TWO_PI;
|
||||
newYmag = mouseY/PApplet.parseFloat(height) * TWO_PI;
|
||||
|
||||
float diff = xmag-newXmag;
|
||||
if (abs(diff) > 0.01f) { xmag -= diff/4.0f; }
|
||||
|
||||
diff = ymag-newYmag;
|
||||
if (abs(diff) > 0.01f) { ymag -= diff/4.0f; }
|
||||
|
||||
rotateX(-ymag);
|
||||
rotateY(-xmag);
|
||||
|
||||
scale(90);
|
||||
beginShape(QUADS);
|
||||
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
|
||||
endShape();
|
||||
|
||||
popMatrix();
|
||||
}
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "RGBCube" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
/**
|
||||
* RGB Cube.
|
||||
*
|
||||
* The three primary colors of the additive color model are red, green, and blue.
|
||||
* This RGB color cube displays smooth transitions between these colors.
|
||||
*/
|
||||
|
||||
float xmag, ymag = 0;
|
||||
float newXmag, newYmag = 0;
|
||||
|
||||
void setup()
|
||||
{
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
colorMode(RGB, 1);
|
||||
}
|
||||
|
||||
void draw()
|
||||
{
|
||||
background(0.5);
|
||||
|
||||
pushMatrix();
|
||||
|
||||
translate(width/2, height/2, -30);
|
||||
|
||||
newXmag = mouseX/float(width) * TWO_PI;
|
||||
newYmag = mouseY/float(height) * TWO_PI;
|
||||
|
||||
float diff = xmag-newXmag;
|
||||
if (abs(diff) > 0.01) { xmag -= diff/4.0; }
|
||||
|
||||
diff = ymag-newYmag;
|
||||
if (abs(diff) > 0.01) { ymag -= diff/4.0; }
|
||||
|
||||
rotateX(-ymag);
|
||||
rotateY(-xmag);
|
||||
|
||||
scale(90);
|
||||
beginShape(QUADS);
|
||||
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
|
||||
fill(0, 1, 0); vertex(-1, 1, -1);
|
||||
fill(1, 1, 0); vertex( 1, 1, -1);
|
||||
fill(1, 1, 1); vertex( 1, 1, 1);
|
||||
fill(0, 1, 1); vertex(-1, 1, 1);
|
||||
|
||||
fill(0, 0, 0); vertex(-1, -1, -1);
|
||||
fill(1, 0, 0); vertex( 1, -1, -1);
|
||||
fill(1, 0, 1); vertex( 1, -1, 1);
|
||||
fill(0, 0, 1); vertex(-1, -1, 1);
|
||||
|
||||
endShape();
|
||||
|
||||
popMatrix();
|
||||
}
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,162 @@
|
||||
/**
|
||||
* Legs class
|
||||
* By Ira Greenberg <br />
|
||||
* Processing for Flash Developers,
|
||||
* Friends of ED, 2009
|
||||
*/
|
||||
|
||||
class Legs {
|
||||
// Instance properties with default values
|
||||
float x = 0, y = 0, z = 0, w = 150, ht = 125;
|
||||
color col = #77AA22;
|
||||
// Advanced properties
|
||||
float detailW = w/6.0;
|
||||
float detailHt = ht/8.0;
|
||||
float shoeBulge = detailHt*2.0;
|
||||
float legGap = w/7.0;
|
||||
|
||||
// Dynamics properties
|
||||
float velocity = .02, stepL, stepR, stepRate = random(10, 50);
|
||||
float speedX = 1.0, speedZ, spring, damping = .5, theta;
|
||||
|
||||
// Default constructor
|
||||
Legs() {
|
||||
}
|
||||
|
||||
// Standard constructor
|
||||
Legs(float x, float z, float w, float ht, color col) {
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.w = w;
|
||||
this.ht = ht;
|
||||
this.col = col;
|
||||
fill(col);
|
||||
detailW = w/6.0;
|
||||
detailHt = ht/8.0;
|
||||
shoeBulge = detailHt*2.0;
|
||||
legGap = w/7.0;
|
||||
speedX = random(-speedX, speedX);
|
||||
}
|
||||
|
||||
// Advanced constructor
|
||||
Legs(float x, float z, float w, float ht, color col, float detailW,
|
||||
float detailHt, float shoeBulge, float legGap) {
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.w = w;
|
||||
this.ht = ht;
|
||||
this.col = col;
|
||||
this.detailW = detailW;
|
||||
this.detailHt = detailHt;
|
||||
this.shoeBulge = shoeBulge;
|
||||
this.legGap = legGap;
|
||||
speedX = random(-speedX, speedX);
|
||||
}
|
||||
|
||||
// Draw legs
|
||||
void create() {
|
||||
fill(col);
|
||||
float footWidth = (w - legGap)/2;
|
||||
beginShape();
|
||||
vertex(x - w/2, y - ht, z);
|
||||
vertex(x - w/2, y - ht + detailHt, z);
|
||||
vertex(x - w/2 + detailW, y - ht + detailHt, z);
|
||||
// left foot
|
||||
vertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW - shoeBulge, y + detailHt/2 + stepL, z);
|
||||
curveVertex(x - w/2, y + detailHt + stepL, z);
|
||||
curveVertex(x - w/2, y + detailHt + stepL, z);
|
||||
vertex(x - w/2 + footWidth, y + detailHt + stepL*.9, z);
|
||||
// end left foot
|
||||
vertex(x - w/2 + footWidth + legGap/2, y - ht + detailHt, z);
|
||||
vertex(x - w/2 + footWidth + legGap/2, y - ht + detailHt, z);
|
||||
// right foot
|
||||
vertex(x - w/2 + footWidth + legGap, y + detailHt + stepR*.9, z);
|
||||
vertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2 - detailW + shoeBulge, y + detailHt/2 + stepR, z);
|
||||
curveVertex(x + w/2 - detailW, y + stepR, z);
|
||||
vertex(x + w/2 - detailW, y + stepR, z);
|
||||
// end right foot
|
||||
vertex(x + w/2 - detailW, y - ht + detailHt, z);
|
||||
vertex(x + w/2, y - ht + detailHt, z);
|
||||
vertex(x + w/2, y - ht, z);
|
||||
endShape(CLOSE);
|
||||
}
|
||||
|
||||
// Set advanced property values
|
||||
void setDetails(float detailW, float detailHt, float shoeBulge, float legGap) {
|
||||
this.detailW = detailW;
|
||||
this.detailHt = detailHt;
|
||||
this.shoeBulge = shoeBulge;
|
||||
this.legGap = legGap;
|
||||
}
|
||||
|
||||
// Make the legs step
|
||||
void step(float stepRate) {
|
||||
this.stepRate = stepRate;
|
||||
spring = ht/2.0;
|
||||
stepL = sin(theta)*spring;
|
||||
stepR = cos(theta)*spring;
|
||||
theta += radians(stepRate);
|
||||
}
|
||||
|
||||
// Alternative overloaded step method
|
||||
void step() {
|
||||
spring = ht/2.0;
|
||||
stepL = sin(theta)*spring;
|
||||
stepR = cos(theta)*spring;
|
||||
theta += radians(stepRate);
|
||||
}
|
||||
|
||||
|
||||
// Moves legs along x, y, z axes
|
||||
void move() {
|
||||
// Move legs along y-axis
|
||||
y = stepR*damping;
|
||||
|
||||
// Move legs along x-axis and
|
||||
// check for collision against frame edge
|
||||
x += speedX;
|
||||
if (screenX(x, y, z) > width) {
|
||||
speedX *= -1;
|
||||
}
|
||||
if (screenX(x, y, z) < 0) {
|
||||
speedX *= -1;
|
||||
}
|
||||
|
||||
// Move legs along z-axis based on speed of stepping
|
||||
// and check for collision against extremes
|
||||
speedZ = (stepRate*velocity);
|
||||
z += speedZ;
|
||||
if (z > 400) {
|
||||
z = 400;
|
||||
velocity *= -1;
|
||||
}
|
||||
if (z < -100) {
|
||||
z = -100;
|
||||
velocity *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
void setDynamics(float speedX, float spring, float damping) {
|
||||
this.speedX = speedX;
|
||||
this.spring = spring;
|
||||
this.damping = damping;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* Run-Amuck
|
||||
* By Ira Greenberg <br />
|
||||
* Processing for Flash Developers,
|
||||
* Friends of ED, 2009
|
||||
*/
|
||||
|
||||
int count = 250;
|
||||
Legs[] legs = new Legs[count];
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
for (int i = 0; i < legs.length; i++) {
|
||||
legs[i] = new Legs(random(-10, 10), random(-50, 150), random(.5, 5),
|
||||
random(.5, 5), color(random(255), random(255), random(255)));
|
||||
}
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(0);
|
||||
translate(width/2, height/2);
|
||||
noStroke();
|
||||
fill(35);
|
||||
|
||||
// Draw ground plane
|
||||
beginShape();
|
||||
vertex(-width*2, 0, -1000);
|
||||
vertex(width*2, 0, -1000);
|
||||
vertex(width/2, height/2, 400);
|
||||
vertex(-width/2, height/2, 400);
|
||||
endShape(CLOSE);
|
||||
|
||||
// Update and draw the legs
|
||||
for (int i = 0; i < legs.length; i++) {
|
||||
legs[i].create();
|
||||
// Set foot step rate
|
||||
legs[i].step(random(10, 50));
|
||||
// Move legs along x, y, z axes
|
||||
// z-movement dependent upon step rate
|
||||
legs[i].move();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
/**
|
||||
* Legs class
|
||||
* By Ira Greenberg <br />
|
||||
* Processing for Flash Developers,
|
||||
* Friends of ED, 2009
|
||||
*/
|
||||
|
||||
class Legs {
|
||||
// Instance properties with default values
|
||||
float x = 0, y = 0, z = 0, w = 150, ht = 125;
|
||||
color col = #77AA22;
|
||||
// Advanced properties
|
||||
float detailW = w/6.0;
|
||||
float detailHt = ht/8.0;
|
||||
float shoeBulge = detailHt*2.0;
|
||||
float legGap = w/7.0;
|
||||
|
||||
// Dynamics properties
|
||||
float velocity = .02, stepL, stepR, stepRate = random(10, 50);
|
||||
float speedX = 1.0, speedZ, spring, damping = .5, theta;
|
||||
|
||||
// Default constructor
|
||||
Legs() {
|
||||
}
|
||||
|
||||
// Standard constructor
|
||||
Legs(float x, float z, float w, float ht, color col) {
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.w = w;
|
||||
this.ht = ht;
|
||||
this.col = col;
|
||||
fill(col);
|
||||
detailW = w/6.0;
|
||||
detailHt = ht/8.0;
|
||||
shoeBulge = detailHt*2.0;
|
||||
legGap = w/7.0;
|
||||
speedX = random(-speedX, speedX);
|
||||
}
|
||||
|
||||
// Advanced constructor
|
||||
Legs(float x, float z, float w, float ht, color col, float detailW,
|
||||
float detailHt, float shoeBulge, float legGap) {
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.w = w;
|
||||
this.ht = ht;
|
||||
this.col = col;
|
||||
this.detailW = detailW;
|
||||
this.detailHt = detailHt;
|
||||
this.shoeBulge = shoeBulge;
|
||||
this.legGap = legGap;
|
||||
speedX = random(-speedX, speedX);
|
||||
}
|
||||
|
||||
// Draw legs
|
||||
void create() {
|
||||
fill(col);
|
||||
float footWidth = (w - legGap)/2;
|
||||
beginShape();
|
||||
vertex(x - w/2, y - ht, z);
|
||||
vertex(x - w/2, y - ht + detailHt, z);
|
||||
vertex(x - w/2 + detailW, y - ht + detailHt, z);
|
||||
// left foot
|
||||
vertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW - shoeBulge, y + detailHt/2 + stepL, z);
|
||||
curveVertex(x - w/2, y + detailHt + stepL, z);
|
||||
curveVertex(x - w/2, y + detailHt + stepL, z);
|
||||
vertex(x - w/2 + footWidth, y + detailHt + stepL*.9, z);
|
||||
// end left foot
|
||||
vertex(x - w/2 + footWidth + legGap/2, y - ht + detailHt, z);
|
||||
vertex(x - w/2 + footWidth + legGap/2, y - ht + detailHt, z);
|
||||
// right foot
|
||||
vertex(x - w/2 + footWidth + legGap, y + detailHt + stepR*.9, z);
|
||||
vertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2 - detailW + shoeBulge, y + detailHt/2 + stepR, z);
|
||||
curveVertex(x + w/2 - detailW, y + stepR, z);
|
||||
vertex(x + w/2 - detailW, y + stepR, z);
|
||||
// end right foot
|
||||
vertex(x + w/2 - detailW, y - ht + detailHt, z);
|
||||
vertex(x + w/2, y - ht + detailHt, z);
|
||||
vertex(x + w/2, y - ht, z);
|
||||
endShape(CLOSE);
|
||||
}
|
||||
|
||||
// Set advanced property values
|
||||
void setDetails(float detailW, float detailHt, float shoeBulge, float legGap) {
|
||||
this.detailW = detailW;
|
||||
this.detailHt = detailHt;
|
||||
this.shoeBulge = shoeBulge;
|
||||
this.legGap = legGap;
|
||||
}
|
||||
|
||||
// Make the legs step
|
||||
void step(float stepRate) {
|
||||
this.stepRate = stepRate;
|
||||
spring = ht/2.0;
|
||||
stepL = sin(theta)*spring;
|
||||
stepR = cos(theta)*spring;
|
||||
theta += radians(stepRate);
|
||||
}
|
||||
|
||||
// Alternative overloaded step method
|
||||
void step() {
|
||||
spring = ht/2.0;
|
||||
stepL = sin(theta)*spring;
|
||||
stepR = cos(theta)*spring;
|
||||
theta += radians(stepRate);
|
||||
}
|
||||
|
||||
|
||||
// Moves legs along x, y, z axes
|
||||
void move() {
|
||||
// Move legs along y-axis
|
||||
y = stepR*damping;
|
||||
|
||||
// Move legs along x-axis and
|
||||
// check for collision against frame edge
|
||||
x += speedX;
|
||||
if (screenX(x, y, z) > width) {
|
||||
speedX *= -1;
|
||||
}
|
||||
if (screenX(x, y, z) < 0) {
|
||||
speedX *= -1;
|
||||
}
|
||||
|
||||
// Move legs along z-axis based on speed of stepping
|
||||
// and check for collision against extremes
|
||||
speedZ = (stepRate*velocity);
|
||||
z += speedZ;
|
||||
if (z > 400) {
|
||||
z = 400;
|
||||
velocity *= -1;
|
||||
}
|
||||
if (z < -100) {
|
||||
z = -100;
|
||||
velocity *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
void setDynamics(float speedX, float spring, float damping) {
|
||||
this.speedX = speedX;
|
||||
this.spring = spring;
|
||||
this.damping = damping;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
import processing.core.*;
|
||||
import processing.xml.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class RunAmuck extends PApplet {
|
||||
|
||||
/**
|
||||
* Run-Amuck
|
||||
* By Ira Greenberg <br />
|
||||
* Processing for Flash Developers,
|
||||
* Friends of ED, 2009
|
||||
*/
|
||||
|
||||
int count = 250;
|
||||
Legs[] legs = new Legs[count];
|
||||
|
||||
public void setup() {
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
for (int i = 0; i < legs.length; i++) {
|
||||
legs[i] = new Legs(random(-10, 10), random(-50, 150), random(.5f, 5),
|
||||
random(.5f, 5), color(random(255), random(255), random(255)));
|
||||
}
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
background(0);
|
||||
translate(width/2, height/2);
|
||||
noStroke();
|
||||
fill(35);
|
||||
|
||||
// Draw ground plane
|
||||
beginShape();
|
||||
vertex(-width*2, 0, -1000);
|
||||
vertex(width*2, 0, -1000);
|
||||
vertex(width/2, height/2, 400);
|
||||
vertex(-width/2, height/2, 400);
|
||||
endShape(CLOSE);
|
||||
|
||||
// Update and draw the legs
|
||||
for (int i = 0; i < legs.length; i++) {
|
||||
legs[i].create();
|
||||
// Set foot step rate
|
||||
legs[i].step(random(10, 50));
|
||||
// Move legs along x, y, z axes
|
||||
// z-movement dependent upon step rate
|
||||
legs[i].move();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Legs class
|
||||
* By Ira Greenberg <br />
|
||||
* Processing for Flash Developers,
|
||||
* Friends of ED, 2009
|
||||
*/
|
||||
|
||||
class Legs {
|
||||
// Instance properties with default values
|
||||
float x = 0, y = 0, z = 0, w = 150, ht = 125;
|
||||
int col = 0xff77AA22;
|
||||
// Advanced properties
|
||||
float detailW = w/6.0f;
|
||||
float detailHt = ht/8.0f;
|
||||
float shoeBulge = detailHt*2.0f;
|
||||
float legGap = w/7.0f;
|
||||
|
||||
// Dynamics properties
|
||||
float velocity = .02f, stepL, stepR, stepRate = random(10, 50);
|
||||
float speedX = 1.0f, speedZ, spring, damping = .5f, theta;
|
||||
|
||||
// Default constructor
|
||||
Legs() {
|
||||
}
|
||||
|
||||
// Standard constructor
|
||||
Legs(float x, float z, float w, float ht, int col) {
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.w = w;
|
||||
this.ht = ht;
|
||||
this.col = col;
|
||||
fill(col);
|
||||
detailW = w/6.0f;
|
||||
detailHt = ht/8.0f;
|
||||
shoeBulge = detailHt*2.0f;
|
||||
legGap = w/7.0f;
|
||||
speedX = random(-speedX, speedX);
|
||||
}
|
||||
|
||||
// Advanced constructor
|
||||
Legs(float x, float z, float w, float ht, int col, float detailW,
|
||||
float detailHt, float shoeBulge, float legGap) {
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.w = w;
|
||||
this.ht = ht;
|
||||
this.col = col;
|
||||
this.detailW = detailW;
|
||||
this.detailHt = detailHt;
|
||||
this.shoeBulge = shoeBulge;
|
||||
this.legGap = legGap;
|
||||
speedX = random(-speedX, speedX);
|
||||
}
|
||||
|
||||
// Draw legs
|
||||
public void create() {
|
||||
fill(col);
|
||||
float footWidth = (w - legGap)/2;
|
||||
beginShape();
|
||||
vertex(x - w/2, y - ht, z);
|
||||
vertex(x - w/2, y - ht + detailHt, z);
|
||||
vertex(x - w/2 + detailW, y - ht + detailHt, z);
|
||||
// left foot
|
||||
vertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW, y + stepL, z);
|
||||
curveVertex(x - w/2 + detailW - shoeBulge, y + detailHt/2 + stepL, z);
|
||||
curveVertex(x - w/2, y + detailHt + stepL, z);
|
||||
curveVertex(x - w/2, y + detailHt + stepL, z);
|
||||
vertex(x - w/2 + footWidth, y + detailHt + stepL*.9f, z);
|
||||
// end left foot
|
||||
vertex(x - w/2 + footWidth + legGap/2, y - ht + detailHt, z);
|
||||
vertex(x - w/2 + footWidth + legGap/2, y - ht + detailHt, z);
|
||||
// right foot
|
||||
vertex(x - w/2 + footWidth + legGap, y + detailHt + stepR*.9f, z);
|
||||
vertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2, y + detailHt + stepR, z);
|
||||
curveVertex(x + w/2 - detailW + shoeBulge, y + detailHt/2 + stepR, z);
|
||||
curveVertex(x + w/2 - detailW, y + stepR, z);
|
||||
vertex(x + w/2 - detailW, y + stepR, z);
|
||||
// end right foot
|
||||
vertex(x + w/2 - detailW, y - ht + detailHt, z);
|
||||
vertex(x + w/2, y - ht + detailHt, z);
|
||||
vertex(x + w/2, y - ht, z);
|
||||
endShape(CLOSE);
|
||||
}
|
||||
|
||||
// Set advanced property values
|
||||
public void setDetails(float detailW, float detailHt, float shoeBulge, float legGap) {
|
||||
this.detailW = detailW;
|
||||
this.detailHt = detailHt;
|
||||
this.shoeBulge = shoeBulge;
|
||||
this.legGap = legGap;
|
||||
}
|
||||
|
||||
// Make the legs step
|
||||
public void step(float stepRate) {
|
||||
this.stepRate = stepRate;
|
||||
spring = ht/2.0f;
|
||||
stepL = sin(theta)*spring;
|
||||
stepR = cos(theta)*spring;
|
||||
theta += radians(stepRate);
|
||||
}
|
||||
|
||||
// Alternative overloaded step method
|
||||
public void step() {
|
||||
spring = ht/2.0f;
|
||||
stepL = sin(theta)*spring;
|
||||
stepR = cos(theta)*spring;
|
||||
theta += radians(stepRate);
|
||||
}
|
||||
|
||||
|
||||
// Moves legs along x, y, z axes
|
||||
public void move() {
|
||||
// Move legs along y-axis
|
||||
y = stepR*damping;
|
||||
|
||||
// Move legs along x-axis and
|
||||
// check for collision against frame edge
|
||||
x += speedX;
|
||||
if (screenX(x, y, z) > width) {
|
||||
speedX *= -1;
|
||||
}
|
||||
if (screenX(x, y, z) < 0) {
|
||||
speedX *= -1;
|
||||
}
|
||||
|
||||
// Move legs along z-axis based on speed of stepping
|
||||
// and check for collision against extremes
|
||||
speedZ = (stepRate*velocity);
|
||||
z += speedZ;
|
||||
if (z > 400) {
|
||||
z = 400;
|
||||
velocity *= -1;
|
||||
}
|
||||
if (z < -100) {
|
||||
z = -100;
|
||||
velocity *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
public void setDynamics(float speedX, float spring, float damping) {
|
||||
this.speedX = speedX;
|
||||
this.spring = spring;
|
||||
this.damping = damping;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "--present", "--bgcolor=#666666", "--hide-stop", "RunAmuck" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* Run-Amuck
|
||||
* By Ira Greenberg <br />
|
||||
* Processing for Flash Developers,
|
||||
* Friends of ED, 2009
|
||||
*/
|
||||
|
||||
int count = 250;
|
||||
Legs[] legs = new Legs[count];
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
for (int i = 0; i < legs.length; i++) {
|
||||
legs[i] = new Legs(random(-10, 10), random(-50, 150), random(.5, 5),
|
||||
random(.5, 5), color(random(255), random(255), random(255)));
|
||||
}
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(0);
|
||||
translate(width/2, height/2);
|
||||
noStroke();
|
||||
fill(35);
|
||||
|
||||
// Draw ground plane
|
||||
beginShape();
|
||||
vertex(-width*2, 0, -1000);
|
||||
vertex(width*2, 0, -1000);
|
||||
vertex(width/2, height/2, 400);
|
||||
vertex(-width/2, height/2, 400);
|
||||
endShape(CLOSE);
|
||||
|
||||
// Update and draw the legs
|
||||
for (int i = 0; i < legs.length; i++) {
|
||||
legs[i].create();
|
||||
// Set foot step rate
|
||||
legs[i].step(random(10, 50));
|
||||
// Move legs along x, y, z axes
|
||||
// z-movement dependent upon step rate
|
||||
legs[i].move();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Shape Transform
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* Illustrates the geometric relationship
|
||||
* between Cube, Pyramid, Cone and
|
||||
* Cylinder 3D primitives.
|
||||
*
|
||||
* Instructions:<br />
|
||||
* Up Arrow - increases points<br />
|
||||
* Down Arrow - decreases points<br />
|
||||
* 'p' key toggles between cube/pyramid<br />
|
||||
*/
|
||||
|
||||
int pts = 4;
|
||||
float angle = 0;
|
||||
float radius = 99;
|
||||
float cylinderLength = 95;
|
||||
|
||||
//vertices
|
||||
PVector vertices[][];
|
||||
boolean isPyramid = false;
|
||||
|
||||
float angleInc;
|
||||
|
||||
void setup(){
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
angleInc = PI/300.0;
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(170, 95, 95);
|
||||
lights();
|
||||
fill(255, 200, 200);
|
||||
translate(width/2, height/2);
|
||||
rotateX(frameCount * angleInc);
|
||||
rotateY(frameCount * angleInc);
|
||||
rotateZ(frameCount * angleInc);
|
||||
|
||||
// initialize vertex arrays
|
||||
vertices = new PVector[2][pts+1];
|
||||
|
||||
// fill arrays
|
||||
for (int i = 0; i < 2; i++){
|
||||
angle = 0;
|
||||
for(int j = 0; j <= pts; j++){
|
||||
vertices[i][j] = new PVector();
|
||||
if (isPyramid){
|
||||
if (i==1){
|
||||
vertices[i][j].x = 0;
|
||||
vertices[i][j].y = 0;
|
||||
}
|
||||
else {
|
||||
vertices[i][j].x = cos(radians(angle)) * radius;
|
||||
vertices[i][j].y = sin(radians(angle)) * radius;
|
||||
}
|
||||
}
|
||||
else {
|
||||
vertices[i][j].x = cos(radians(angle)) * radius;
|
||||
vertices[i][j].y = sin(radians(angle)) * radius;
|
||||
}
|
||||
vertices[i][j].z = cylinderLength;
|
||||
// the .0 after the 360 is critical
|
||||
angle += 360.0/pts;
|
||||
}
|
||||
cylinderLength *= -1;
|
||||
}
|
||||
|
||||
// draw cylinder tube
|
||||
beginShape(QUAD_STRIP);
|
||||
for(int j = 0; j <= pts; j++){
|
||||
vertex(vertices[0][j].x, vertices[0][j].y, vertices[0][j].z);
|
||||
vertex(vertices[1][j].x, vertices[1][j].y, vertices[1][j].z);
|
||||
}
|
||||
endShape();
|
||||
|
||||
//draw cylinder ends
|
||||
for (int i = 0; i < 2; i++){
|
||||
beginShape();
|
||||
for(int j = 0; j < pts; j++){
|
||||
vertex(vertices[i][j].x, vertices[i][j].y, vertices[i][j].z);
|
||||
}
|
||||
endShape(CLOSE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
up/down arrow keys control
|
||||
polygon detail.
|
||||
*/
|
||||
void keyPressed(){
|
||||
if(key == CODED) {
|
||||
// pts
|
||||
if (keyCode == UP) {
|
||||
if (pts < 90){
|
||||
pts++;
|
||||
}
|
||||
}
|
||||
else if (keyCode == DOWN) {
|
||||
if (pts > 4){
|
||||
pts--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (key =='p'){
|
||||
if (isPyramid){
|
||||
isPyramid = false;
|
||||
}
|
||||
else {
|
||||
isPyramid = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,147 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class ShapeTransform extends PApplet {
|
||||
|
||||
/**
|
||||
* Shape Transform
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* Illustrates the geometric relationship
|
||||
* between Cube, Pyramid, Cone and
|
||||
* Cylinder 3D primitives.
|
||||
*
|
||||
* Instructions:
|
||||
* Up Arrow - increases points
|
||||
* Down Arrow - decreases points
|
||||
* 'p' key toggles between cube/pyramid
|
||||
*/
|
||||
|
||||
int pts = 7;
|
||||
float angle = 0;
|
||||
float radius = 89;
|
||||
float cylinderLength = 85;
|
||||
|
||||
Point3D vertices[][];
|
||||
boolean isPyramid = false;
|
||||
|
||||
public void setup(){
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
fill(204);
|
||||
}
|
||||
|
||||
public void draw(){
|
||||
background(102);
|
||||
lights();
|
||||
|
||||
translate(width/2, height/2, 0);
|
||||
rotateX(frameCount * 0.006f);
|
||||
rotateY(frameCount * 0.006f);
|
||||
rotateZ(frameCount * 0.006f);
|
||||
|
||||
// initialize point arrays
|
||||
vertices = new Point3D[2][pts+1];
|
||||
|
||||
// fill arrays
|
||||
for (int i = 0; i < 2; i++){
|
||||
angle = 0;
|
||||
for(int j = 0; j <= pts; j++){
|
||||
vertices[i][j] = new Point3D();
|
||||
if (isPyramid){
|
||||
if (i==1){
|
||||
vertices[i][j].x = 0;
|
||||
vertices[i][j].y = 0;
|
||||
}
|
||||
else {
|
||||
vertices[i][j].x = cos(radians(angle))*radius;
|
||||
vertices[i][j].y = sin(radians(angle))*radius;
|
||||
}
|
||||
}
|
||||
else {
|
||||
vertices[i][j].x = cos(radians(angle))*radius;
|
||||
vertices[i][j].y = sin(radians(angle))*radius;
|
||||
}
|
||||
vertices[i][j].z = cylinderLength;
|
||||
// the .0 after the 360 is critical
|
||||
angle += 360.0f/pts;
|
||||
}
|
||||
cylinderLength*=-1;
|
||||
}
|
||||
|
||||
// draw cylinder tube
|
||||
beginShape(QUAD_STRIP);
|
||||
for (int j = 0; j <= pts; j++){
|
||||
vertex(vertices[0][j].x, vertices[0][j].y, vertices[0][j].z);
|
||||
vertex(vertices[1][j].x, vertices[1][j].y, vertices[1][j].z);
|
||||
}
|
||||
endShape();
|
||||
|
||||
//draw cylinder ends
|
||||
for (int i = 0; i < 2; i++){
|
||||
beginShape();
|
||||
for (int j = 0; j < pts; j++){
|
||||
vertex(vertices[i][j].x, vertices[i][j].y, vertices[i][j].z);
|
||||
}
|
||||
endShape(CLOSE);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
up/down arrow keys control
|
||||
polygon detail.
|
||||
*/
|
||||
public void keyPressed(){
|
||||
if(key == CODED) {
|
||||
// pts
|
||||
if (keyCode == UP) {
|
||||
if (pts<90){
|
||||
pts++;
|
||||
}
|
||||
}
|
||||
else if (keyCode == DOWN) {
|
||||
if (pts > 4){
|
||||
pts--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (key == 'p'){
|
||||
if (isPyramid){
|
||||
isPyramid=false;
|
||||
}
|
||||
else {
|
||||
isPyramid=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
class Point3D{
|
||||
float x, y, z;
|
||||
|
||||
// constructors
|
||||
Point3D(){
|
||||
}
|
||||
|
||||
Point3D(float x, float y, float z){
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
}
|
||||
}
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "ShapeTransform" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
/**
|
||||
* Shape Transform
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* Illustrates the geometric relationship
|
||||
* between Cube, Pyramid, Cone and
|
||||
* Cylinder 3D primitives.
|
||||
*
|
||||
* Instructions:
|
||||
* Up Arrow - increases points
|
||||
* Down Arrow - decreases points
|
||||
* 'p' key toggles between cube/pyramid
|
||||
*/
|
||||
|
||||
int pts = 7;
|
||||
float angle = 0;
|
||||
float radius = 89;
|
||||
float cylinderLength = 85;
|
||||
|
||||
Point3D vertices[][];
|
||||
boolean isPyramid = false;
|
||||
|
||||
void setup(){
|
||||
size(640, 360, P3D);
|
||||
noStroke();
|
||||
fill(204);
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(102);
|
||||
lights();
|
||||
|
||||
translate(width/2, height/2, 0);
|
||||
rotateX(frameCount * 0.006);
|
||||
rotateY(frameCount * 0.006);
|
||||
rotateZ(frameCount * 0.006);
|
||||
|
||||
// initialize point arrays
|
||||
vertices = new Point3D[2][pts+1];
|
||||
|
||||
// fill arrays
|
||||
for (int i = 0; i < 2; i++){
|
||||
angle = 0;
|
||||
for(int j = 0; j <= pts; j++){
|
||||
vertices[i][j] = new Point3D();
|
||||
if (isPyramid){
|
||||
if (i==1){
|
||||
vertices[i][j].x = 0;
|
||||
vertices[i][j].y = 0;
|
||||
}
|
||||
else {
|
||||
vertices[i][j].x = cos(radians(angle))*radius;
|
||||
vertices[i][j].y = sin(radians(angle))*radius;
|
||||
}
|
||||
}
|
||||
else {
|
||||
vertices[i][j].x = cos(radians(angle))*radius;
|
||||
vertices[i][j].y = sin(radians(angle))*radius;
|
||||
}
|
||||
vertices[i][j].z = cylinderLength;
|
||||
// the .0 after the 360 is critical
|
||||
angle += 360.0/pts;
|
||||
}
|
||||
cylinderLength*=-1;
|
||||
}
|
||||
|
||||
// draw cylinder tube
|
||||
beginShape(QUAD_STRIP);
|
||||
for (int j = 0; j <= pts; j++){
|
||||
vertex(vertices[0][j].x, vertices[0][j].y, vertices[0][j].z);
|
||||
vertex(vertices[1][j].x, vertices[1][j].y, vertices[1][j].z);
|
||||
}
|
||||
endShape();
|
||||
|
||||
//draw cylinder ends
|
||||
for (int i = 0; i < 2; i++){
|
||||
beginShape();
|
||||
for (int j = 0; j < pts; j++){
|
||||
vertex(vertices[i][j].x, vertices[i][j].y, vertices[i][j].z);
|
||||
}
|
||||
endShape(CLOSE);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
up/down arrow keys control
|
||||
polygon detail.
|
||||
*/
|
||||
void keyPressed(){
|
||||
if(key == CODED) {
|
||||
// pts
|
||||
if (keyCode == UP) {
|
||||
if (pts<90){
|
||||
pts++;
|
||||
}
|
||||
}
|
||||
else if (keyCode == DOWN) {
|
||||
if (pts > 4){
|
||||
pts--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (key == 'p'){
|
||||
if (isPyramid){
|
||||
isPyramid=false;
|
||||
}
|
||||
else {
|
||||
isPyramid=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,182 @@
|
||||
/**
|
||||
* Interactive Toroid
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* Illustrates the geometric relationship between Toroid, Sphere, and Helix
|
||||
* 3D primitives, as well as lathing principal.
|
||||
*
|
||||
* Instructions: <br />
|
||||
* UP arrow key pts++ <br />
|
||||
* DOWN arrow key pts-- <br />
|
||||
* LEFT arrow key segments-- <br />
|
||||
* RIGHT arrow key segments++ <br />
|
||||
* 'a' key toroid radius-- <br />
|
||||
* 's' key toroid radius++ <br />
|
||||
* 'z' key initial polygon radius-- <br />
|
||||
* 'x' key initial polygon radius++ <br />
|
||||
* 'w' key toggle wireframe/solid shading <br />
|
||||
* 'h' key toggle sphere/helix <br />
|
||||
*/
|
||||
|
||||
int pts = 40;
|
||||
float angle = 0;
|
||||
float radius = 60.0;
|
||||
|
||||
// lathe segments
|
||||
int segments = 60;
|
||||
float latheAngle = 0;
|
||||
float latheRadius = 100.0;
|
||||
|
||||
//vertices
|
||||
PVector vertices[], vertices2[];
|
||||
|
||||
// for shaded or wireframe rendering
|
||||
boolean isWireFrame = false;
|
||||
|
||||
// for optional helix
|
||||
boolean isHelix = false;
|
||||
float helixOffset = 5.0;
|
||||
|
||||
void setup(){
|
||||
size(640, 360, P3D);
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(50, 64, 42);
|
||||
// basic lighting setup
|
||||
lights();
|
||||
// 2 rendering styles
|
||||
// wireframe or solid
|
||||
if (isWireFrame){
|
||||
stroke(255, 255, 150);
|
||||
noFill();
|
||||
}
|
||||
else {
|
||||
noStroke();
|
||||
fill(150, 195, 125);
|
||||
}
|
||||
//center and spin toroid
|
||||
translate(width/2, height/2, -100);
|
||||
|
||||
rotateX(frameCount*PI/150);
|
||||
rotateY(frameCount*PI/170);
|
||||
rotateZ(frameCount*PI/90);
|
||||
|
||||
// initialize point arrays
|
||||
vertices = new PVector[pts+1];
|
||||
vertices2 = new PVector[pts+1];
|
||||
|
||||
// fill arrays
|
||||
for(int i=0; i<=pts; i++){
|
||||
vertices[i] = new PVector();
|
||||
vertices2[i] = new PVector();
|
||||
vertices[i].x = latheRadius + sin(radians(angle))*radius;
|
||||
if (isHelix){
|
||||
vertices[i].z = cos(radians(angle))*radius-(helixOffset*
|
||||
segments)/2;
|
||||
}
|
||||
else{
|
||||
vertices[i].z = cos(radians(angle))*radius;
|
||||
}
|
||||
angle+=360.0/pts;
|
||||
}
|
||||
|
||||
// draw toroid
|
||||
latheAngle = 0;
|
||||
for(int i=0; i<=segments; i++){
|
||||
beginShape(QUAD_STRIP);
|
||||
for(int j=0; j<=pts; j++){
|
||||
if (i>0){
|
||||
vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
|
||||
}
|
||||
vertices2[j].x = cos(radians(latheAngle))*vertices[j].x;
|
||||
vertices2[j].y = sin(radians(latheAngle))*vertices[j].x;
|
||||
vertices2[j].z = vertices[j].z;
|
||||
// optional helix offset
|
||||
if (isHelix){
|
||||
vertices[j].z+=helixOffset;
|
||||
}
|
||||
vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
|
||||
}
|
||||
// create extra rotation for helix
|
||||
if (isHelix){
|
||||
latheAngle+=720.0/segments;
|
||||
}
|
||||
else {
|
||||
latheAngle+=360.0/segments;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
left/right arrow keys control ellipse detail
|
||||
up/down arrow keys control segment detail.
|
||||
'a','s' keys control lathe radius
|
||||
'z','x' keys control ellipse radius
|
||||
'w' key toggles between wireframe and solid
|
||||
'h' key toggles between toroid and helix
|
||||
*/
|
||||
void keyPressed(){
|
||||
if(key == CODED) {
|
||||
// pts
|
||||
if (keyCode == UP) {
|
||||
if (pts<40){
|
||||
pts++;
|
||||
}
|
||||
}
|
||||
else if (keyCode == DOWN) {
|
||||
if (pts>3){
|
||||
pts--;
|
||||
}
|
||||
}
|
||||
// extrusion length
|
||||
if (keyCode == LEFT) {
|
||||
if (segments>3){
|
||||
segments--;
|
||||
}
|
||||
}
|
||||
else if (keyCode == RIGHT) {
|
||||
if (segments<80){
|
||||
segments++;
|
||||
}
|
||||
}
|
||||
}
|
||||
// lathe radius
|
||||
if (key =='a'){
|
||||
if (latheRadius>0){
|
||||
latheRadius--;
|
||||
}
|
||||
}
|
||||
else if (key == 's'){
|
||||
latheRadius++;
|
||||
}
|
||||
// ellipse radius
|
||||
if (key =='z'){
|
||||
if (radius>10){
|
||||
radius--;
|
||||
}
|
||||
}
|
||||
else if (key == 'x'){
|
||||
radius++;
|
||||
}
|
||||
// wireframe
|
||||
if (key =='w'){
|
||||
if (isWireFrame){
|
||||
isWireFrame=false;
|
||||
}
|
||||
else {
|
||||
isWireFrame=true;
|
||||
}
|
||||
}
|
||||
// helix
|
||||
if (key =='h'){
|
||||
if (isHelix){
|
||||
isHelix=false;
|
||||
}
|
||||
else {
|
||||
isHelix=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,215 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class Toroid extends PApplet {
|
||||
|
||||
/**
|
||||
* Interactive Toroid
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* Illustrates the geometric relationship
|
||||
* between Toroid, Sphere, and Helix
|
||||
* 3D primitives, as well as lathing
|
||||
* principal.
|
||||
*
|
||||
* Instructions:
|
||||
* UP arrow key pts++;
|
||||
* DOWN arrow key pts--;
|
||||
* LEFT arrow key segments--;
|
||||
* RIGHT arrow key segments++;
|
||||
* 'a' key toroid radius--;
|
||||
* 's' key toroid radius++;
|
||||
* 'z' key initial polygon radius--;
|
||||
* 'x' key initial polygon radius++;
|
||||
* 'w' key toggle wireframe/solid shading
|
||||
* 'h' key toggle sphere/helix
|
||||
*/
|
||||
|
||||
|
||||
int pts = 40;
|
||||
float angle = 0;
|
||||
float radius = 40.0f;
|
||||
// Lathe segments
|
||||
int segments = 60;
|
||||
float latheAngle = 0;
|
||||
float latheRadius = 100.0f;
|
||||
// Vertices
|
||||
Point3D vertices[], vertices2[];
|
||||
// For shaded or wireframe rendering
|
||||
boolean isWireFrame = false;
|
||||
// For optional helix
|
||||
boolean isHelix = false;
|
||||
float helixOffset = 5.0f;
|
||||
|
||||
public void setup() {
|
||||
size(640, 360, P3D);
|
||||
}
|
||||
|
||||
public void draw(){
|
||||
background(51);
|
||||
// Basic lighting setup
|
||||
lights();
|
||||
// Two rendering styles
|
||||
// Wireframe or solid
|
||||
if (isWireFrame){
|
||||
stroke(255);
|
||||
noFill();
|
||||
}
|
||||
else {
|
||||
noStroke();
|
||||
fill(204);
|
||||
}
|
||||
// Center and spin toroid
|
||||
translate(width/2, height/2, -100);
|
||||
|
||||
rotateX(frameCount*PI/150);
|
||||
rotateY(frameCount*PI/170);
|
||||
rotateZ(frameCount*PI/90);
|
||||
|
||||
// Initialize point arrays
|
||||
vertices = new Point3D[pts+1];
|
||||
vertices2 = new Point3D[pts+1];
|
||||
|
||||
// Fill arrays
|
||||
for(int i = 0; i <= pts; i++){
|
||||
vertices[i] = new Point3D();
|
||||
vertices2[i] = new Point3D();
|
||||
vertices[i].x = latheRadius + sin(radians(angle))*radius;
|
||||
if (isHelix){
|
||||
vertices[i].z = cos(radians(angle))*radius-(helixOffset*
|
||||
segments)/2;
|
||||
}
|
||||
else{
|
||||
vertices[i].z = cos(radians(angle))*radius;
|
||||
}
|
||||
angle+=360.0f/pts;
|
||||
}
|
||||
|
||||
// Draw toroid
|
||||
latheAngle = 0;
|
||||
for(int i = 0; i <= segments; i++){
|
||||
beginShape(QUAD_STRIP);
|
||||
for(int j = 0; j <= pts; j++){
|
||||
if (i > 0){
|
||||
vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
|
||||
}
|
||||
vertices2[j].x = cos(radians(latheAngle))*vertices[j].x;
|
||||
vertices2[j].y = sin(radians(latheAngle))*vertices[j].x;
|
||||
vertices2[j].z = vertices[j].z;
|
||||
// Optional helix offset
|
||||
if (isHelix){
|
||||
vertices[j].z+=helixOffset;
|
||||
}
|
||||
vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
|
||||
}
|
||||
// Create extra rotation for helix
|
||||
if (isHelix){
|
||||
latheAngle += 720.0f/segments;
|
||||
}
|
||||
else {
|
||||
latheAngle += 360.0f/segments;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
left/right arrow keys control ellipse detail
|
||||
up/down arrow keys control segment detail.
|
||||
'a','s' keys control lathe radius
|
||||
'z','x' keys control ellipse radius
|
||||
'w' key toggles between wireframe and solid
|
||||
'h' key toggles between toroid and helix
|
||||
*/
|
||||
public void keyPressed(){
|
||||
if(key == CODED) {
|
||||
// pts
|
||||
if (keyCode == UP) {
|
||||
if (pts < 40){
|
||||
pts++;
|
||||
}
|
||||
}
|
||||
else if (keyCode == DOWN) {
|
||||
if (pts > 3){
|
||||
pts--;
|
||||
}
|
||||
}
|
||||
// Extrusion length
|
||||
if (keyCode == LEFT) {
|
||||
if (segments > 3){
|
||||
segments--;
|
||||
}
|
||||
}
|
||||
else if (keyCode == RIGHT) {
|
||||
if (segments < 80){
|
||||
segments++;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Lathe radius
|
||||
if (key =='a'){
|
||||
if (latheRadius > 0){
|
||||
latheRadius--;
|
||||
}
|
||||
}
|
||||
else if (key == 's'){
|
||||
latheRadius++;
|
||||
}
|
||||
// Ellipse radius
|
||||
if (key =='z'){
|
||||
if (radius > 10){
|
||||
radius--;
|
||||
}
|
||||
}
|
||||
else if (key == 'x'){
|
||||
radius++;
|
||||
}
|
||||
// Wireframe
|
||||
if (key == 'w'){
|
||||
if (isWireFrame){
|
||||
isWireFrame=false;
|
||||
}
|
||||
else {
|
||||
isWireFrame=true;
|
||||
}
|
||||
}
|
||||
// Helix
|
||||
if (key == 'h'){
|
||||
if (isHelix){
|
||||
isHelix=false;
|
||||
}
|
||||
else {
|
||||
isHelix=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class Point3D{
|
||||
float x, y, z;
|
||||
|
||||
// constructors
|
||||
Point3D(){
|
||||
}
|
||||
|
||||
Point3D(float x, float y, float z){
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
}
|
||||
}
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "Toroid" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
/**
|
||||
* Interactive Toroid
|
||||
* by Ira Greenberg.
|
||||
*
|
||||
* Illustrates the geometric relationship
|
||||
* between Toroid, Sphere, and Helix
|
||||
* 3D primitives, as well as lathing
|
||||
* principal.
|
||||
*
|
||||
* Instructions:
|
||||
* UP arrow key pts++;
|
||||
* DOWN arrow key pts--;
|
||||
* LEFT arrow key segments--;
|
||||
* RIGHT arrow key segments++;
|
||||
* 'a' key toroid radius--;
|
||||
* 's' key toroid radius++;
|
||||
* 'z' key initial polygon radius--;
|
||||
* 'x' key initial polygon radius++;
|
||||
* 'w' key toggle wireframe/solid shading
|
||||
* 'h' key toggle sphere/helix
|
||||
*/
|
||||
|
||||
|
||||
int pts = 40;
|
||||
float angle = 0;
|
||||
float radius = 40.0;
|
||||
// Lathe segments
|
||||
int segments = 60;
|
||||
float latheAngle = 0;
|
||||
float latheRadius = 100.0;
|
||||
// Vertices
|
||||
Point3D vertices[], vertices2[];
|
||||
// For shaded or wireframe rendering
|
||||
boolean isWireFrame = false;
|
||||
// For optional helix
|
||||
boolean isHelix = false;
|
||||
float helixOffset = 5.0;
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
}
|
||||
|
||||
void draw(){
|
||||
background(51);
|
||||
// Basic lighting setup
|
||||
lights();
|
||||
// Two rendering styles
|
||||
// Wireframe or solid
|
||||
if (isWireFrame){
|
||||
stroke(255);
|
||||
noFill();
|
||||
}
|
||||
else {
|
||||
noStroke();
|
||||
fill(204);
|
||||
}
|
||||
// Center and spin toroid
|
||||
translate(width/2, height/2, -100);
|
||||
|
||||
rotateX(frameCount*PI/150);
|
||||
rotateY(frameCount*PI/170);
|
||||
rotateZ(frameCount*PI/90);
|
||||
|
||||
// Initialize point arrays
|
||||
vertices = new Point3D[pts+1];
|
||||
vertices2 = new Point3D[pts+1];
|
||||
|
||||
// Fill arrays
|
||||
for(int i = 0; i <= pts; i++){
|
||||
vertices[i] = new Point3D();
|
||||
vertices2[i] = new Point3D();
|
||||
vertices[i].x = latheRadius + sin(radians(angle))*radius;
|
||||
if (isHelix){
|
||||
vertices[i].z = cos(radians(angle))*radius-(helixOffset*
|
||||
segments)/2;
|
||||
}
|
||||
else{
|
||||
vertices[i].z = cos(radians(angle))*radius;
|
||||
}
|
||||
angle+=360.0/pts;
|
||||
}
|
||||
|
||||
// Draw toroid
|
||||
latheAngle = 0;
|
||||
for(int i = 0; i <= segments; i++){
|
||||
beginShape(QUAD_STRIP);
|
||||
for(int j = 0; j <= pts; j++){
|
||||
if (i > 0){
|
||||
vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
|
||||
}
|
||||
vertices2[j].x = cos(radians(latheAngle))*vertices[j].x;
|
||||
vertices2[j].y = sin(radians(latheAngle))*vertices[j].x;
|
||||
vertices2[j].z = vertices[j].z;
|
||||
// Optional helix offset
|
||||
if (isHelix){
|
||||
vertices[j].z+=helixOffset;
|
||||
}
|
||||
vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
|
||||
}
|
||||
// Create extra rotation for helix
|
||||
if (isHelix){
|
||||
latheAngle += 720.0/segments;
|
||||
}
|
||||
else {
|
||||
latheAngle += 360.0/segments;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
left/right arrow keys control ellipse detail
|
||||
up/down arrow keys control segment detail.
|
||||
'a','s' keys control lathe radius
|
||||
'z','x' keys control ellipse radius
|
||||
'w' key toggles between wireframe and solid
|
||||
'h' key toggles between toroid and helix
|
||||
*/
|
||||
void keyPressed(){
|
||||
if(key == CODED) {
|
||||
// pts
|
||||
if (keyCode == UP) {
|
||||
if (pts < 40){
|
||||
pts++;
|
||||
}
|
||||
}
|
||||
else if (keyCode == DOWN) {
|
||||
if (pts > 3){
|
||||
pts--;
|
||||
}
|
||||
}
|
||||
// Extrusion length
|
||||
if (keyCode == LEFT) {
|
||||
if (segments > 3){
|
||||
segments--;
|
||||
}
|
||||
}
|
||||
else if (keyCode == RIGHT) {
|
||||
if (segments < 80){
|
||||
segments++;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Lathe radius
|
||||
if (key =='a'){
|
||||
if (latheRadius > 0){
|
||||
latheRadius--;
|
||||
}
|
||||
}
|
||||
else if (key == 's'){
|
||||
latheRadius++;
|
||||
}
|
||||
// Ellipse radius
|
||||
if (key =='z'){
|
||||
if (radius > 10){
|
||||
radius--;
|
||||
}
|
||||
}
|
||||
else if (key == 'x'){
|
||||
radius++;
|
||||
}
|
||||
// Wireframe
|
||||
if (key == 'w'){
|
||||
if (isWireFrame){
|
||||
isWireFrame=false;
|
||||
}
|
||||
else {
|
||||
isWireFrame=true;
|
||||
}
|
||||
}
|
||||
// Helix
|
||||
if (key == 'h'){
|
||||
if (isHelix){
|
||||
isHelix=false;
|
||||
}
|
||||
else {
|
||||
isHelix=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Vertices
|
||||
* by Simon Greenwold.
|
||||
*
|
||||
* Draw a cylinder centered on the y-axis, going down
|
||||
* from y=0 to y=height. The radius at the top can be
|
||||
* different from the radius at the bottom, and the
|
||||
* number of sides drawn is variable.
|
||||
*/
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(0);
|
||||
lights();
|
||||
translate(width / 2, height / 2);
|
||||
rotateY(map(mouseX, 0, width, 0, PI));
|
||||
rotateZ(map(mouseY, 0, height, 0, -PI));
|
||||
noStroke();
|
||||
fill(255, 255, 255);
|
||||
translate(0, -40, 0);
|
||||
drawCylinder(10, 180, 200, 16); // Draw a mix between a cylinder and a cone
|
||||
//drawCylinder(70, 70, 120, 64); // Draw a cylinder
|
||||
//drawCylinder(0, 180, 200, 4); // Draw a pyramid
|
||||
}
|
||||
|
||||
void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {
|
||||
float angle = 0;
|
||||
float angleIncrement = TWO_PI / sides;
|
||||
beginShape(QUAD_STRIP);
|
||||
for (int i = 0; i < sides + 1; ++i) {
|
||||
vertex(topRadius*cos(angle), 0, topRadius*sin(angle));
|
||||
vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
|
||||
// If it is not a cone, draw the circular top cap
|
||||
if (topRadius != 0) {
|
||||
angle = 0;
|
||||
beginShape(TRIANGLE_FAN);
|
||||
|
||||
// Center point
|
||||
vertex(0, 0, 0);
|
||||
for (int i = 0; i < sides + 1; i++) {
|
||||
vertex(topRadius * cos(angle), 0, topRadius * sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
|
||||
// If it is not a cone, draw the circular bottom cap
|
||||
if (bottomRadius != 0) {
|
||||
angle = 0;
|
||||
beginShape(TRIANGLE_FAN);
|
||||
|
||||
// Center point
|
||||
vertex(0, tall, 0);
|
||||
for (int i = 0; i < sides + 1; i++) {
|
||||
vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
import processing.core.*;
|
||||
|
||||
import java.applet.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.text.*;
|
||||
import java.util.*;
|
||||
import java.util.zip.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class Vertices extends PApplet {
|
||||
|
||||
/**
|
||||
* Vertices
|
||||
* by Simon Greenwold.
|
||||
*
|
||||
* Draw a cylinder centered on the y-axis, going down
|
||||
* from y=0 to y=height. The radius at the top can be
|
||||
* different from the radius at the bottom, and the
|
||||
* number of sides drawn is variable.
|
||||
*/
|
||||
|
||||
public void setup() {
|
||||
size(640, 360, P3D);
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
background(0);
|
||||
lights();
|
||||
translate(width / 2, height / 2);
|
||||
rotateY(map(mouseX, 0, width, 0, PI));
|
||||
rotateZ(map(mouseY, 0, height, 0, -PI));
|
||||
noStroke();
|
||||
fill(255, 255, 255);
|
||||
translate(0, -40, 0);
|
||||
drawCylinder(10, 180, 200, 16); // Draw a mix between a cylinder and a cone
|
||||
//drawCylinder(70, 70, 120, 64); // Draw a cylinder
|
||||
//drawCylinder(0, 180, 200, 4); // Draw a pyramid
|
||||
}
|
||||
|
||||
public void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {
|
||||
float angle = 0;
|
||||
float angleIncrement = TWO_PI / sides;
|
||||
beginShape(QUAD_STRIP);
|
||||
for (int i = 0; i < sides + 1; ++i) {
|
||||
vertex(topRadius*cos(angle), 0, topRadius*sin(angle));
|
||||
vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
|
||||
// If it is not a cone, draw the circular top cap
|
||||
if (topRadius != 0) {
|
||||
angle = 0;
|
||||
beginShape(TRIANGLE_FAN);
|
||||
|
||||
// Center point
|
||||
vertex(0, 0, 0);
|
||||
for (int i = 0; i < sides + 1; i++) {
|
||||
vertex(topRadius * cos(angle), 0, topRadius * sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
|
||||
// If it is not a cone, draw the circular bottom cap
|
||||
if (bottomRadius != 0) {
|
||||
angle = 0;
|
||||
beginShape(TRIANGLE_FAN);
|
||||
|
||||
// Center point
|
||||
vertex(0, tall, 0);
|
||||
for (int i = 0; i < sides + 1; i++) {
|
||||
vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
|
||||
static public void main(String args[]) {
|
||||
PApplet.main(new String[] { "Vertices" });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Vertices
|
||||
* by Simon Greenwold.
|
||||
*
|
||||
* Draw a cylinder centered on the y-axis, going down
|
||||
* from y=0 to y=height. The radius at the top can be
|
||||
* different from the radius at the bottom, and the
|
||||
* number of sides drawn is variable.
|
||||
*/
|
||||
|
||||
void setup() {
|
||||
size(640, 360, P3D);
|
||||
}
|
||||
|
||||
void draw() {
|
||||
background(0);
|
||||
lights();
|
||||
translate(width / 2, height / 2);
|
||||
rotateY(map(mouseX, 0, width, 0, PI));
|
||||
rotateZ(map(mouseY, 0, height, 0, -PI));
|
||||
noStroke();
|
||||
fill(255, 255, 255);
|
||||
translate(0, -40, 0);
|
||||
drawCylinder(10, 180, 200, 16); // Draw a mix between a cylinder and a cone
|
||||
//drawCylinder(70, 70, 120, 64); // Draw a cylinder
|
||||
//drawCylinder(0, 180, 200, 4); // Draw a pyramid
|
||||
}
|
||||
|
||||
void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {
|
||||
float angle = 0;
|
||||
float angleIncrement = TWO_PI / sides;
|
||||
beginShape(QUAD_STRIP);
|
||||
for (int i = 0; i < sides + 1; ++i) {
|
||||
vertex(topRadius*cos(angle), 0, topRadius*sin(angle));
|
||||
vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
|
||||
// If it is not a cone, draw the circular top cap
|
||||
if (topRadius != 0) {
|
||||
angle = 0;
|
||||
beginShape(TRIANGLE_FAN);
|
||||
|
||||
// Center point
|
||||
vertex(0, 0, 0);
|
||||
for (int i = 0; i < sides + 1; i++) {
|
||||
vertex(topRadius * cos(angle), 0, topRadius * sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
|
||||
// If it is not a cone, draw the circular bottom cap
|
||||
if (bottomRadius != 0) {
|
||||
angle = 0;
|
||||
beginShape(TRIANGLE_FAN);
|
||||
|
||||
// Center point
|
||||
vertex(0, tall, 0);
|
||||
for (int i = 0; i < sides + 1; i++) {
|
||||
vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));
|
||||
angle += angleIncrement;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
}
|
||||
|
After Width: | Height: | Size: 2.2 KiB |