Sindbad~EG File Manager
/*
* @(#)Rotator3D.java 1.18 06/08/24
*
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
* AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
* AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or intended
* for use in the design, construction, operation or maintenance of any
* nuclear facility.
*/
/*
* @(#)Rotator3D.java 1.18 06/08/24
*/
package java2d.demos.Colors;
import java.awt.*;
import java2d.AnimatingSurface;
import static java.lang.Math.*;
/**
* 3D objects with color & lighting translated, rotated and scaled.
*/
public class Rotator3D extends AnimatingSurface {
private Objects3D objs[] = new Objects3D[3];
private static final int[][][] polygons =
{
// Solid cube
{{5, 1, 15, 13, 21, 23, 15},
{5, 2, 21, 13, 19, 27, 21},
{5, 3, 23, 15, 17, 25, 23},
{5, 4, 19, 13, 15, 17, 19},
{5, 5, 27, 21, 23, 25, 27},
{5, 6, 27, 19, 17, 25, 27}},
// Polygonal faces cube
{{5, 1, 21, 13, 19, 27, 21},
{5, 5, 23, 15, 17, 25, 23},
{4,0,15,14,16,15}, {7,6,16,14,13,12,18,17,16}, {4,0,12,19,18,12},
{4,2,22,21,20,22}, {7,0,24,23,22,20,27,26,24}, {4,2,24,26,25,24},
{4, 3, 15, 13, 23, 15}, {4, 0, 23, 13, 21, 23},
{5, 0, 27, 26, 18, 19, 27}, {5, 4, 25, 17, 18, 26, 25}},
// Octahedron
{{4, 3, 18, 21, 16, 18}, {4, 1, 20, 16, 18, 20},
{4, 1, 18, 21, 16, 18}, {4, 3, 20, 17, 19, 20},
{4, 2, 20, 26, 27, 20}, {5, 3, 26, 18, 16, 27, 26},
{5, 0, 17, 24, 25, 19, 17}, {4, 3, 21, 25, 24, 21},
{4, 4, 18, 21, 22, 18}, {4, 2, 22, 21, 17, 22},
{4, 5, 20, 23, 16, 20}, {4, 1, 20, 23, 19, 20},
{4, 6, 21, 23, 16, 21}, {4, 4, 21, 23, 19, 21},
{4, 5, 20, 18, 22, 20}, {4, 6, 20, 22, 17, 20}}
};
private static final double[][][] points =
{
// Points for solid cube & polygonal faces cube
{{ 1, 0, 0}, {-1, 0, 0}, { 0, 1, 0}, { 0, -1, 0}, { 0, 0, 1},
{ 0, 0, -1}, { 1, 0, 0}, {-1, 0, 0}, { 0, 1, 0}, { 0, -1, 0},
{ 0, 0, 1}, { 0, 0, -1}, { 1, 1, 0}, { 1, 1, 1}, { 0, 1, 1},
{-1, 1, 1}, {-1, 1, 0}, {-1, 1, -1}, { 0, 1, -1}, { 1, 1, -1},
{ 1, -1, 0}, { 1, -1, 1}, { 0, -1, 1}, {-1, -1, 1}, {-1, -1, 0},
{-1, -1, -1}, { 0, -1, -1}, { 1, -1, -1}},
// Points for octahedron
{{0, 0, 1}, {0, 0, -1}, {-0.8165, 0.4714, 0.33333},
{0.8165, -0.4714, -0.33333}, {0.8165, 0.4714, 0.33333},
{-0.8165, -0.4714, -0.33333}, {0, -0.9428, 0.3333},
{0, 0.9428, -0.33333}, {0, 0, 1}, {0, 0, -1},
{-0.8165, 0.4714, 0.33333}, {0.8165, -0.4714, -0.33333},
{0.8165, 0.4714, 0.33333}, {-0.8165, -0.4714, -0.33333},
{0, -0.9428, 0.33333}, {0, 0.9428, -0.33333},
{-1.2247, -0.7071, 1}, {1.2247, 0.7071, -1},
{0, 1.4142, 1}, {0, -1.4142, -1}, {-1.2247, 0.7071, -1},
{1.2247, -0.7071, 1}, {0.61237, 1.06066, 0},
{-0.61237, -1.06066, 0}, {1.2247, 0, 0},
{0.61237, -1.06066, 0}, {-0.61237, 1.06066, 0}, {-1.2247, 0, 0}}
};
private static final int[][][] faces =
{
// Solid cube
{{1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 0}, {1, 5}},
// Polygonal faces cube
{{1, 0}, {1, 1}, {3, 2, 3, 4}, {3, 5, 6, 7}, {2,8,9}, {2,10,11}},
// Octahedron
{{1, 2}, {1, 3}, {2, 4, 5}, {2, 6, 7}, {2, 8, 9},
{2, 10, 11}, {2, 12, 13}, {2, 14, 15}},
};
public Rotator3D() {
setBackground(Color.white);
}
public void reset(int w, int h) {
objs[0] = new Objects3D(polygons[0], points[0], faces[0], w, h);
objs[1] = new Objects3D(polygons[1], points[0], faces[1], w, h);
objs[2] = new Objects3D(polygons[2], points[1], faces[2], w, h);
}
public void step(int w, int h) {
for (Objects3D obj : objs) {
if (obj != null) {
obj.step(w, h);
}
}
}
public void render(int w, int h, Graphics2D g2) {
for (Objects3D obj : objs) {
if (obj != null) {
obj.render(g2);
}
}
}
public static void main(String argv[]) {
createDemoFrame(new Rotator3D());
}
/**
* 3D Objects : Solid Cube, Cube & Octahedron with polygonal faces.
*/
public class Objects3D {
private final int UP = 0;
private final int DOWN = 1;
private int[][] polygons;
private int npoly;
private double[][] points;
private int npoint;
private int[][] faces;
private int nface;
private int ncolour = 10;
private Color[][] colours = new Color[ncolour][7];
private double[] lightvec = {0, 1, 1};
private double Zeye = 10;
private double angle;
private Matrix3D orient, tmp, tmp2, tmp3;
private int scaleDirection;
private double scale, scaleAmt;
private double ix = 3.0, iy = 3.0;
private double[][] rotPts;
private int[][] scrPts;
private int xx[] = new int[20];
private int yy[] = new int[20];
private double x, y;
private int p, j;
private int colour;
private double bounce, persp;
public Objects3D(int[][] polygons,
double[][] points,
int[][] faces,
int w,
int h) {
this.polygons = polygons;
this.points = points;
this.faces = faces;
npoly = polygons.length;
npoint = points.length;
nface = faces.length;
x = w * random();
y = h * random();
ix = random() > 0.5 ? ix : -ix;
iy = random() > 0.5 ? iy : -iy;
rotPts = new double[npoint][3];
scrPts = new int[npoint][2];
for (int i = 0; i < ncolour; i++) {
int x = 255 - (ncolour - i - 1)*100/ncolour;
Color[] c = {
new Color(x,x,x), // white
new Color(x,0,0), // red
new Color(0,x,0), // green
new Color(0,0,x), // blue
new Color(x,x,0), // yellow
new Color(0,x,x), // cyan
new Color(x,0,x) // magenta
};
colours[i] = c;
}
double len = sqrt(lightvec[0]*lightvec[0] +
lightvec[1]*lightvec[1] +
lightvec[2]*lightvec[2]);
lightvec[0] = lightvec[0]/len;
lightvec[1] = lightvec[1]/len;
lightvec[2] = lightvec[2]/len;
double max = 0;
for (int i = 0; i < npoint; i++) {
len = sqrt(points[i][0]*points[i][0] +
points[i][1]*points[i][1] +
points[i][2]*points[i][2]);
if (len >max) {
max = len;
}
}
for (int i = 0; i < nface; i++) {
len = sqrt(points[i][0]*points[i][0] +
points[i][1]*points[i][1] +
points[i][2]*points[i][2]);
points[i][0] = points[i][0]/len;
points[i][1] = points[i][1]/len;
points[i][2] = points[i][2]/len;
}
orient = new Matrix3D();
tmp = new Matrix3D();
tmp2 = new Matrix3D();
tmp3 = new Matrix3D();
tmp.Rotation(2,0,PI/50);
CalcScrPts((double) w/3,(double) h/3, 0);
scale = min(w/3/max/1.2, h/3/max/1.2);
scaleAmt = scale;
scale *= random() * 1.5;
scaleDirection = scaleAmt < scale ? DOWN : UP;
}
private Color getColour(int f,int index) {
colour = (int)((rotPts[f][0]*lightvec[0] +
rotPts[f][1]*lightvec[1] +
rotPts[f][2]*lightvec[2]) * ncolour);
if (colour < 0) {
colour = 0;
}
if (colour > ncolour-1) {
colour = ncolour-1;
}
return colours[colour][polygons[faces[f][index]][1]];
}
private void CalcScrPts(double x, double y, double z) {
for (p = 0; p < npoint; p++) {
rotPts[p][2] = points[p][0]*orient.M[2][0]
+ points[p][1]*orient.M[2][1]
+ points[p][2]*orient.M[2][2];
rotPts[p][0] = points[p][0]*orient.M[0][0]
+ points[p][1]*orient.M[0][1]
+ points[p][2]*orient.M[0][2];
rotPts[p][1] = - points[p][0]*orient.M[1][0]
- points[p][1]*orient.M[1][1]
- points[p][2]*orient.M[1][2];
}
for (p = nface; p < npoint; p++) {
rotPts[p][2] += z;
persp = (Zeye - rotPts[p][2])/(scale*Zeye);
scrPts[p][0] = (int)(rotPts[p][0]/persp+x);
scrPts[p][1] = (int)(rotPts[p][1]/persp+y);
}
}
private boolean faceUp(int f) {
return (rotPts[f][0] * rotPts[nface+f][0] +
rotPts[f][1] * rotPts[nface+f][1] +
rotPts[f][2] *(rotPts[nface+f][2]-Zeye) < 0);
}
public void step(int w, int h) {
x += ix;
y += iy;
if (x > w-scale) {
x = w-scale-1;
ix = -w/100 - 1;
}
if (x-scale < 0) {
x = 2+scale;
ix = w/100 + random()*3;
}
if (y > h-scale) {
y = h-scale-2;
iy = -h/100 - 1;
}
if (y-scale < 0) {
y = 2+scale;
iy = h/100 + random()*3;
}
angle += random() * 0.15;
tmp3.Rotation(1, 2, angle);
tmp2.Rotation(1, 0, angle*sqrt(2)/2);
tmp.Rotation(0, 2, angle*PI/4);
orient.M = tmp3.Times(tmp2.Times(tmp.M));
bounce = abs(cos(0.5*(angle)))*2-1;
if (scale > scaleAmt*1.4) {
scaleDirection = DOWN;
}
if (scale < scaleAmt*0.4) {
scaleDirection = UP;
}
if (scaleDirection == UP) {
scale += random();
}
if (scaleDirection == DOWN) {
scale -= random();
}
CalcScrPts(x, y, bounce);
}
public void render(Graphics2D g2) {
for (int f = 0;f < nface; f++) {
if (faceUp(f)) {
for (j = 1;j < faces[f][0]+1; j++) {
DrawPoly(g2, faces[f][j], getColour(f,j));
}
}
}
}
private void DrawPoly(Graphics2D g2, int poly, Color colour) {
for (int p = 2; p < polygons[poly][0]+2; p++) {
xx[p-2] = scrPts[polygons[poly][p]][0];
yy[p-2] = scrPts[polygons[poly][p]][1];
}
g2.setColor(colour);
g2.fillPolygon(xx,yy,polygons[poly][0]);
g2.setColor(Color.black);
g2.drawPolygon(xx,yy,polygons[poly][0]);
}
/**
* A 3D matrix object.
*/
public class Matrix3D {
public double[][] M = { { 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 } };
private double[][] tmp = new double[3][3];
private int row, col, k;
public void Rotation(int i, int j, double angle) {
for (row = 0; row < 3; row++) {
for (col = 0; col <3; col++) {
if (row != col) {
M[row][col] = 0.0;
} else {
M[row][col] = 1.0;
}
}
}
M[i][i] = cos(angle);
M[j][j] = cos(angle);
M[i][j] = sin(angle);
M[j][i] = -sin(angle);
}
public double[][] Times(double[][] N) {
for (row = 0; row < 3; row++) {
for (col = 0; col < 3; col++) {
tmp[row][col] = 0.0;
for (k = 0; k < 3; k++) {
tmp[row][col] += M[row][k] * N[k][col];
}
}
}
return tmp;
}
} // End Matrix3D
} // End Objects3D
} // End Rotator3D
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists