Category

Development Platform
Home > SourceCode/Document > Graph program > 2D Graphic > View Code
Rotator3D.java
Package: Java2D.rar　[view]
Upload User: cdlibang
Upload Date: 2016-07-17
Package Size: 774k
Code Size: 15k
Category:

2D Graphic

Development Platform:

Java

Rotator3D.java：Code Content
  1. /*
  2.  * @(#)Rotator3D.java 1.7 99/04/23
  3.  *
  4.  * Copyright (c) 1998, 1999 by Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
  7.  * modify and redistribute this software in source and binary code form,
  8.  * provided that i) this copyright notice and license appear on all copies of
  9.  * the software; and ii) Licensee does not utilize the software in a manner
  10.  * which is disparaging to Sun.
  11.  * 
  12.  * This software is provided "AS IS," without a warranty of any kind. ALL
  13.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  14.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  15.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  16.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  17.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  18.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  19.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  20.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  21.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  22.  * POSSIBILITY OF SUCH DAMAGES.
  23.  * 
  24.  * This software is not designed or intended for use in on-line control of
  25.  * aircraft, air traffic, aircraft navigation or aircraft communications; or in
  26.  * the design, construction, operation or maintenance of any nuclear
  27.  * facility. Licensee represents and warrants that it will not use or
  28.  * redistribute the Software for such purposes.
  29.  */
  30. /*
  31.  * @(#)Rotator3D.java 1.7 99/04/23
  32.  * 
  33.  * Copyright 1993-1998 Sun Microsystems, Inc. 901 San Antonio Road, 
  34.  * Palo Alto, California, 94303, U.S.A.  All Rights Reserved.
  35.  * 
  36.  * This software is the confidential and proprietary information of Sun
  37.  * Microsystems, Inc. ("Confidential Information").  You shall not
  38.  * disclose such Confidential Information and shall use it only in
  39.  * accordance with the terms of the license agreement you entered into
  40.  * with Sun.
  41.  * 
  42.  * CopyrightVersion 1.2
  43.  * 
  44.  */
  46. package demos.Colors;
  48. import java.awt.*;
  49. import java.awt.event.*;
  50. import AnimatingContext;
  51. import DemoSurface;
  52. import DemoPanel;
  55. /**
  56.  * 3D objects with color & lighting translated, rotated and scaled.
  57.  */
  58. public class Rotator3D extends DemoSurface implements AnimatingContext {
  60.     private Objects3D objs[] = new Objects3D[3];
  61.     private static final int[][][] polygons = 
  62.              { 
  63.         // Solid cube   
  64.               {{5, 1, 15, 13, 21, 23, 15}, 
  65.                {5, 2, 21, 13, 19, 27, 21},
  66.                {5, 3, 23, 15, 17, 25, 23}, 
  67.                {5, 4, 19, 13, 15, 17, 19},
  68.                {5, 5, 27, 21, 23, 25, 27},
  69.                {5, 6, 27, 19, 17, 25, 27}},
  70.         // Polygonal faces cube
  71.               {{5, 1, 21, 13, 19, 27, 21},
  72.                {5, 5, 23, 15, 17, 25, 23}, 
  73.                {4,0,15,14,16,15}, {7,6,16,14,13,12,18,17,16}, {4,0,12,19,18,12},
  74.                {4,2,22,21,20,22}, {7,0,24,23,22,20,27,26,24}, {4,2,24,26,25,24},
  75.                {4, 3, 15, 13, 23, 15}, {4, 0, 23, 13, 21, 23}, 
  76.                {5, 0, 27, 26, 18, 19, 27}, {5, 4, 25, 17, 18, 26, 25}}, 
  77.         // Octahedron
  78.               {{4, 3, 18, 21, 16, 18}, {4, 1, 20, 16, 18, 20}, 
  79.                {4, 1, 18, 21, 16, 18}, {4, 3, 20, 17, 19, 20}, 
  80.                {4, 2, 20, 26, 27, 20}, {5, 3, 26, 18, 16, 27, 26}, 
  81.                {5, 0, 17, 24, 25, 19, 17}, {4, 3, 21, 25, 24, 21}, 
  82.                {4, 4, 18, 21, 22, 18}, {4, 2, 22, 21, 17, 22}, 
  83.                {4, 5, 20, 23, 16, 20}, {4, 1, 20, 23, 19, 20}, 
  84.                {4, 6, 21, 23, 16, 21}, {4, 4, 21, 23, 19, 21}, 
  85.                {4, 5, 20, 18, 22, 20}, {4, 6, 20, 22, 17, 20}}
  86.              };
  87.     private static final double[][][] points = 
  88.            { 
  89.         // Points for solid cube & polygonal faces cube
  90.             {{1, 0, 0}, {-1, 0, 0}, {0, 1, 0}, {0, -1, 0}, {0, 0, 1}, 
  91.              {0, 0, -1}, {1, 0, 0}, {-1, 0, 0}, {0, 1, 0}, {0, -1, 0}, 
  92.              {0, 0, 1}, {0, 0, -1}, {1, 1, 0}, {1, 1, 1}, {0, 1, 1}, 
  93.              {-1, 1, 1}, {-1, 1, 0}, {-1, 1, -1}, {0, 1, -1}, {1, 1, -1}, 
  94.              {1, -1, 0}, {1, -1, 1}, {0, -1, 1}, {-1, -1, 1}, {-1, -1, 0}, 
  95.              {-1, -1, -1}, {0, -1, -1}, {1, -1, -1}},
  96.         // Points for octahedron
  97.             {{0, 0, 1}, {0, 0, -1}, {-0.8165, 0.4714, 0.33333},
  98.              {0.8165, -0.4714, -0.33333}, {0.8165, 0.4714, 0.33333},
  99.              {-0.8165, -0.4714, -0.33333}, {0, -0.9428, 0.3333},
  100.              {0, 0.9428, -0.33333}, {0, 0, 1}, {0, 0, -1},
  101.              {-0.8165, 0.4714, 0.33333}, {0.8165, -0.4714, -0.33333}, 
  102.              {0.8165, 0.4714, 0.33333}, {-0.8165, -0.4714, -0.33333},  
  103.              {0, -0.9428, 0.33333}, {0, 0.9428, -0.33333},  
  104.              {-1.2247, -0.7071, 1}, {1.2247, 0.7071, -1}, 
  105.              {0, 1.4142, 1}, {0, -1.4142, -1}, {-1.2247, 0.7071, -1}, 
  106.              {1.2247, -0.7071, 1}, {0.61237, 1.06066, 0}, 
  107.              {-0.61237, -1.06066, 0}, {1.2247, 0, 0}, 
  108.              {0.61237, -1.06066, 0}, {-0.61237, 1.06066, 0}, {-1.2247, 0, 0}}
  109.            }; 
  110.     private static final int[][][] faces = 
  111.            { 
  112.          // Solid cube
  113.              {{1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 0}, {1, 5}},
  114.          // Polygonal faces cube
  115.              {{1, 0}, {1, 1}, {3, 2, 3, 4}, {3, 5, 6, 7}, {2,8,9}, {2,10,11}},
  116.          // Octahedron
  117.              {{1, 2}, {1, 3}, {2, 4, 5}, {2, 6, 7}, {2, 8, 9}, 
  118.               {2, 10, 11}, {2, 12, 13}, {2, 14, 15}},
  119.            };
  122.     public Rotator3D() {
  123.         setBackground(Color.white);
  124.     }
  127.     public void reset(int w, int h) {
  128.         objs[0] = new Objects3D(polygons[0], points[0], faces[0], w, h);
  129.         objs[1] = new Objects3D(polygons[1], points[0], faces[1], w, h);
  130.         objs[2] = new Objects3D(polygons[2], points[1], faces[2], w, h);
  131.     }
  134.     public void step(int w, int h) {
  135.         for (int i = objs.length; i-- > 0; ) {
  136.             if (objs[i] != null) {
  137.                 objs[i].step(w, h);
  138.             }
  139.         }
  140.     }
  143.     public void drawDemo(int w, int h, Graphics2D g2) {
  145.         for (int i = objs.length; i-- > 0; ) {
  146.             if (objs[i] != null) {
  147.                 objs[i].Draw(g2);
  148.             }
  149.         }
  150.     }
  153.     public static void main(String argv[]) {
  154.         final DemoPanel dp = new DemoPanel(new Rotator3D());
  155.         Frame f = new Frame("Java2D Demo - Rotator3D");
  156.         f.addWindowListener(new WindowAdapter() {
  157.             public void windowClosing(WindowEvent e) {System.exit(0);}
  158.             public void windowDeiconified(WindowEvent e) { 
  159.                 dp.surface.start(); 
  160.             }
  161.             public void windowIconified(WindowEvent e) { 
  162.                 dp.surface.stop(); 
  163.             }
  164.         });
  165.         f.add("Center", dp);
  166.         f.pack();
  167.         f.setSize(new Dimension(400,300));
  168.         f.show();
  169.         dp.surface.start();
  170.     }
  173. /**
  174.  * 3D Objects : Solid Cube, Cube & Octahedron with polygonal faces.
  175.  */
  176. public class Objects3D {
  178.     private final int UP = 0;
  179.     private final int DOWN = 1;
  180.     private int[][] polygons;
  181.     private int npoly;
  182.     private double[][] points;
  183.     private int npoint;
  184.     private int[][] faces;
  185.     private int nface;
  186.     private int ncolour = 10;
  187.     private Color[][] colours = new Color[ncolour][7];
  188.     private double[] lightvec = {0, 1, 1}; 
  189.     private double Zeye = 10;
  190.     private double angle;
  191.     private Matrix3D orient, tmp, tmp2, tmp3;
  192.     private int scaleDirection;
  193.     private double scale, scaleAmt;
  194.     private double ix = 3.0, iy = 3.0;
  195.     private double[][] rotPts;
  196.     private int[][] scrPts;
  197.     private int xx[] = new int[20];
  198.     private int yy[] = new int[20];
  199.     private double x, y;
  200.     private int p, j;
  201.     private int colour;
  202.     private double bounce, persp;
  204.  
  205.     public Objects3D(int[][] polygons, 
  206.                      double[][] points, 
  207.                      int[][] faces, 
  208.                      int w, 
  209.                      int h) {
  211.         this.polygons = polygons;
  212.         this.points = points;
  213.         this.faces = faces;
  214.         npoly = polygons.length;
  215.         npoint = points.length;
  216.         nface = faces.length;
  218.         x = w * Math.random();
  219.         y = h * Math.random();
  221.         ix = Math.random() > 0.5 ? ix : -ix;
  222.         iy = Math.random() > 0.5 ? iy : -iy;
  224.         rotPts = new double[npoint][3];
  225.         scrPts = new int[npoint][2];
  226.                     
  227.         for (int i = 0; i < ncolour; i++) {
  228.             // white
  229.             colours[i][0]= new Color(255 -(ncolour-1-i)*100/ncolour,
  230.                 255 -(ncolour-1-i)*100/ncolour,255 -(ncolour-1-i)*100/ncolour);
  231.             // red
  232.             colours[i][1]= new Color(255 -(ncolour-1-i)*100/ncolour,0,0);
  233.             // green
  234.             colours[i][2]= new Color(0,255 -(ncolour-1-i)*100/ncolour,0);
  235.             // blue
  236.             colours[i][3]= new Color(0,0,255 -(ncolour-1-i)*100/ncolour);
  237.             // yellow
  238.             colours[i][4]= new Color(255 -(ncolour-1-i)*100/ncolour,
  239.                 255 -(ncolour-1-i)*100/ncolour,0);
  240.             // cyan
  241.             colours[i][5]= new Color(0, 255 -(ncolour-1-i)*100/ncolour,
  242.                 255 -(ncolour-1-i)*100/ncolour);
  243.             // magenta
  244.             colours[i][6]= new Color(255 -(ncolour-1-i)*100/ncolour, 0,
  245.                 255 -(ncolour-1-i)*100/ncolour);
  246.         }
  248.         double len = Math.sqrt(lightvec[0]*lightvec[0] + 
  249.                                lightvec[1]*lightvec[1] + 
  250.                                lightvec[2]*lightvec[2]);
  251.         lightvec[0] = lightvec[0]/len;
  252.         lightvec[1] = lightvec[1]/len;
  253.         lightvec[2] = lightvec[2]/len;
  255.         double max = 0;
  256.         for (int i = 0; i < npoint; i++) {
  257.             len = Math.sqrt(points[i][0]*points[i][0] + 
  258.                     points[i][1]*points[i][1] + points[i][2]*points[i][2]);
  259.             if (len >max) {
  260.                 max = len;
  261.             }
  262.         }
  263.    
  264.         for (int i = 0; i < nface; i++) {
  265.             len = Math.sqrt(points[i][0]*points[i][0] + 
  266.                     points[i][1]*points[i][1] + points[i][2]*points[i][2]);
  267.             points[i][0] = points[i][0]/len;
  268.             points[i][1] = points[i][1]/len;
  269.             points[i][2] = points[i][2]/len;
  270.         }
  272.         orient = new Matrix3D();
  273.         tmp = new Matrix3D();
  274.         tmp2 = new Matrix3D();
  275.         tmp3 = new Matrix3D();
  276.         tmp.Rotation(2,0,Math.PI/50);
  277.         CalcScrPts((double) w/3,(double) h/3, 0);
  279.         scale = Math.min(w/3/max/1.2, h/3/max/1.2);
  280.         scaleAmt = scale;
  281.         scale *= Math.random() * 1.5;
  282.         scaleDirection = scaleAmt < scale ? DOWN : UP;
  283.     }
  285.  
  286.     private Color getColour(int f,int index) {
  287.         colour = (int)((rotPts[f][0]*lightvec[0]+ rotPts[f][1]*lightvec[1] 
  288.                     + rotPts[f][2]*lightvec[2])*ncolour); 
  289.         if (colour < 0) {
  290.             colour = 0;
  291.         }
  292.         if (colour > ncolour-1) {
  293.             colour = ncolour-1;
  294.         }
  295.         return colours[colour][polygons[faces[f][index]][1]];
  296.     }
  297.       
  299.     private void CalcScrPts(double x, double y, double z) {
  300.         for (p = 0; p < npoint; p++) {
  301.             rotPts[p][2] = points[p][0]*orient.M[2][0] + 
  302.                            points[p][1]*orient.M[2][1] +
  303.                            points[p][2]*orient.M[2][2];
  304.             rotPts[p][0] = points[p][0]*orient.M[0][0] + 
  305.                            points[p][1]*orient.M[0][1] +
  306.                            points[p][2]*orient.M[0][2];
  307.             rotPts[p][1] = -points[p][0]*orient.M[1][0] - 
  308.                            points[p][1]*orient.M[1][1] -
  309.                            points[p][2]*orient.M[1][2];
  310.         }
  311.         for (p = nface; p < npoint; p++) {
  312.             rotPts[p][2] += z;
  313.             persp = (Zeye - rotPts[p][2])/(scale*Zeye);
  314.             scrPts[p][0] = (int)(rotPts[p][0]/persp+x);
  315.             scrPts[p][1] = (int)(rotPts[p][1]/persp+y);
  316.         }
  317.     }
  320.     private boolean faceUp(int f) {
  321.         return (rotPts[f][0]*rotPts[nface+f][0] + 
  322.                 rotPts[f][1]*rotPts[nface+f][1] + 
  323.                 rotPts[f][2]*(rotPts[nface+f][2]-Zeye) < 0);
  324.     }
  325.     
  327.     public void step(int w, int h) {
  328.         x += ix;
  329.         y += iy;
  330.         if (x > w-scale) {
  331.             x = w-scale-1;
  332.             ix = -w/100 - 1;
  333.         }
  334.         if (x-scale < 0) {
  335.             x = 2+scale;
  336.             ix = w/100 + Math.random()*3;
  337.         }
  338.         if (y > h-scale) {
  339.             y = h-scale-2;
  340.             iy = -h/100 - 1;
  341.         }
  342.         if (y-scale < 0) {
  343.             y = 2+scale;
  344.             iy = h/100 + Math.random()*3;
  345.         }
  347.         angle += Math.random() * 0.15;
  348.         tmp3.Rotation(1, 2, angle);
  349.         tmp2.Rotation(1, 0, angle*Math.sqrt(2)/2);
  350.         tmp.Rotation(0, 2, angle*Math.PI/4);
  351.         orient.M = tmp3.Times(tmp2.Times(tmp.M));
  352.         bounce = Math.abs(Math.cos(0.5*(angle)))*2-1;
  354.         if (scale > scaleAmt*1.4) {
  355.             scaleDirection = DOWN;
  356.         }
  357.         if (scale < scaleAmt*0.4) {
  358.             scaleDirection = UP;
  359.         }
  360.         if (scaleDirection == UP) {
  361.             scale += Math.random();
  362.         }
  363.         if (scaleDirection == DOWN) {
  364.             scale -= Math.random();
  365.         }
  367.         CalcScrPts(x, y, bounce);
  368.     }
  371.     public void Draw(Graphics2D g2) {
  372.      
  373.         for (int f = 0;f < nface; f++) {
  374.             if (faceUp(f)) {
  375.                 for (j = 1;j < faces[f][0]+1; j++) {
  376.                     DrawPoly(g2, faces[f][j], getColour(f,j));
  377.                 }
  378.             }
  379.         } 
  380.     } 
  383.     private void DrawPoly(Graphics2D g2, int poly, Color colour) {
  384.         for (int p = 2; p < polygons[poly][0]+2; p++) {
  385.             xx[p-2] = scrPts[polygons[poly][p]][0];
  386.             yy[p-2] = scrPts[polygons[poly][p]][1];
  387.         }
  388.         g2.setColor(colour); 
  389.         g2.fillPolygon(xx,yy,polygons[poly][0]);
  390.         g2.setColor(Color.black); 
  391.         g2.drawPolygon(xx,yy,polygons[poly][0]);
  392.     }
  395. /** 
  396.  * A 3D matrix object.
  397.  */
  398. public class Matrix3D {
  400.     public double[][] M = { { 1, 0, 0 },
  401.                             { 0, 1, 0 },
  402.                             { 0, 0, 1 } };
  403.     private double[][] tmp = new double[3][3];
  404.     private int row, col, k;
  405.  
  406.     public void Rotation(int i, int j, double angle) {
  407.         for (row = 0; row < 3; row++) {
  408.             for (col = 0; col <3; col++) {
  409.                 if (row != col) { 
  410.                     M[row][col] = 0.0; 
  411.                 } else { 
  412.                     M[row][col] = 1.0; 
  413.                 }
  414.             }
  415.         }
  416.         M[i][i] = Math.cos(angle);
  417.         M[j][j] = Math.cos(angle);
  418.         M[i][j] = Math.sin(angle);
  419.         M[j][i] = -Math.sin(angle);
  420.     }
  422.     public double[][] Times(double[][] N) {
  423.         for (row = 0; row < 3; row++) {
  424.             for (col = 0; col < 3; col++) {
  425.                 tmp[row][col] = 0.0;
  426.                 for (k = 0; k < 3; k++) {
  427.                     tmp[row][col] += M[row][k] * N[k][col];
  428.                 }
  429.             }
  430.         }
  431.         return tmp;
  432.     }
  434. } // End Matrix3D
  436. } // End Objects3D
  438. } // End Rotator3D