//
```import java.awt.*;

// A VERY SIMPLE 3D RENDERER BUILT IN JAVA 1.0 - KEN PERLIN

public class Shape
{
public final int CUBE = 0;
public final int CYLINDER = 1;
public final int NTYPES = 2;

private int type = CUBE;

// SHAPE DATA FOR A CUBE

private static int[][] cubeFace = {
{4,5,7,6}, {5,1,3,7}, {6,7,3,2}, {0,2,3,1}, {4,6,2,0}, {0,1,5,4}
};

private static double[][] cubeVertices = {
{-1,-1,-1}, { 1,-1,-1}, {-1, 1,-1}, { 1, 1,-1},
{-1,-1, 1}, { 1,-1, 1}, {-1, 1, 1}, { 1, 1, 1},
};

// SHAPE DATA FOR A PYRAMID

private static int[][] pyramidFace = {
};

private static double[][] pyramidVertices = {
};

public int[][] face;
public double[][] vertices;

// CONSTRUCTOR

public Shape() {
Matrix.identity(matrix);
useShape(cubeFace, cubeVertices);
}

// ALTERNATE SHAPES

public void cube() {
useShape(cubeFace, cubeVertices);
}

int cylinderFace[][][] = new int[100][][];
double cylinderVertices[][][] = new double[100][][];

public void cylinder(int n) {
cylinder(n, true);
}
public void cylinder(int n, boolean capped) {
n = Math.max(3, Math.min(99, n));
if (cylinderFace[n] == null) {
cylinderFace[n] = new int[n+(capped?2:0)][];
for (int i = 0 ; i < n ; i++) {
cylinderFace[n][i] = new int[4];
cylinderFace[n][i][0] = i;
cylinderFace[n][i][1] = (i+1)%n;
cylinderFace[n][i][2] = n + (i+1)%n;
cylinderFace[n][i][3] = n + i;
}
if (capped) {
cylinderFace[n][n  ] = new int[n];
cylinderFace[n][n+1] = new int[n];
for (int i = 0 ; i < n ; i++) {
cylinderFace[n][n  ][i] = n-1-i;
cylinderFace[n][n+1][i] = n+i;
}
}
cylinderVertices[n] = new double[2*n][3];
for (int i = 0 ; i < n ; i++) {
double theta = 2 * i * Math.PI / n;
double cos = Math.cos(theta);
double sin = Math.sin(theta);
Vec.set(cylinderVertices[n][  i], cos, sin, -1);
Vec.set(cylinderVertices[n][n+i], cos, sin,  1);
}
}
useShape(cylinderFace[n], cylinderVertices[n]);
}

// PUBLIC ACCESS FUNCTIONS

public void setColor(double[] src) {
Vec.copy(src, color);
}

public void getColor(double[] dst) {
Vec.copy(color, dst);
}

public void setTranslation(double[] src) {
Vec.copy(src, translation);
mustRecalc = true;
}

public void setRotation(double[] src) {
Vec.copy(src, rotation);
mustRecalc = true;
}

public void setScale(double[] src) {
Vec.copy(src, scale);
mustRecalc = true;
}

public void getTranslation(double[] dst) {
Vec.copy(translation, dst);
}

public void getRotation(double[] dst) {
Vec.copy(rotation, dst);
}

public void getScale(double[] dst) {
Vec.copy(scale, dst);
}

public void getMatrix(double[][] m) {
if (mustRecalc) {
Matrix.identity(matrix);
Matrix.translate(matrix, translation[0],translation[1],translation[2]);
Matrix.rotateX(matrix, rotation[0]);
Matrix.rotateY(matrix, rotation[1]);
Matrix.rotateZ(matrix, rotation[2]);
Matrix.scale(matrix, scale[0],scale[1],scale[2]);
mustRecalc = false;
}
Matrix.copy(matrix, m);
}

// INTERNALLY STORED COLOR

private double[] color = { 1,1,1 };

// TRANSLATION X Y Z, ROTATION X Y Z, SCALE X Y Z

private double[] translation = { 0,0,0 };
private double[] rotation    = { 0,0,0 };
private double[] scale       = { 1,1,1 };

// INTERNALLY CALCULATED MATRIX

private double[][] matrix = new double[4][4];

// NEED TO RECALCULATE MATRIX?

private boolean mustRecalc = true;

private void useShape(int[][] f, double[][] v) {
face = f;
vertices = v;
}
}

```