life3d.java

3D演示例子,初步认识3D的绘制,编程. 适合初学者!

		// We are not fully initialised yet; just return.
        if(myCanvas == null || myWorld == null)
            return;

		// If this was a scheduled update, cancel the timer task that caused it.
        if(myRefreshTask!=null)
        {
			myRefreshTask.cancel();
			myRefreshTask=null;
		}

		// Render the world to our Graphics (the screen) using the m3g class Graphics3D
		// Note the use of try/finally to ensure that the Graphics3D always releases
		// the target no matter what happens.

        Graphics3D myGraphics3D = Graphics3D.getInstance();
        myGraphics3D.bindTarget(g);
        try
        {
	        myGraphics3D.render(myWorld);
	    }
		finally
		{
	        myGraphics3D.releaseTarget();
	 	}

		// Draw information about the pattern: its name, the number of generations,
		// and the number of live cells.
		g.setColor(0xFFFFFFFF);
		g.drawString(generations+" : "+population, 0, 10, Graphics.LEFT|Graphics.TOP);
		g.drawString(patternName, 0, 0, Graphics.LEFT|Graphics.TOP);

		// Always rotate slowly. We set the orientation of rootGroup to achieve this,
		// rotating it about its local Y (vertical) axis.
        angle+=1.0f;
        rootGroup.setOrientation(angle, 0.0f, 1.0f, 0.0f);

		// This deals with the speed setting. We have a countdown that is set to
		// an initial value of "delay", and when it reaches 0, we update the cells.
		// This allows us to keep rotating the view, even if generation is paused.

		if(--delayCount <= 0)
		{
			delayCount=delay;
			++generations;

			// Garbage collect regularly
	    	System.gc();

			// Now calculate next frame

			// Update all the cells
			for(int i=0; i<NUMCELLS; i++)
				updateNeighbours(i);

			population = 0;

			for(int i=0; i<NUMCELLS; i++)
				updateState(i);


			// If all the cells have died out, restart with a random state.
			if(population==0)
				loadRandomState();
		}

		// And schedule another repaint. This uses the Java timers to schedule
		// another repaint in 50 milliseconds. This is more efficient than doing
		// it immediately, and limits the frame rate to 20 frames/second. It also
		// allows other applications some time!

        myRefreshTask = new RefreshTask();
        myRefreshTimer.schedule(myRefreshTask, 50);
    }

    /**
     *	This loads the cell state from a string stored in the pattern library.
     *	Each live cell is represented in the string using a triplet of characters
     *	showing its x, y and z position. For example, the string "000" represents
	 *	a single live cell at the extreme bottom front right corner.
     */

    private void loadStateFromString(String positions)
    {
		clear();

		for(int i=0;i<positions.length();i+=3)
		{
			int xx = (positions.charAt(i+0)-'0')&(CUBESIZE-1);
			int yy = (positions.charAt(i+1)-'0')&(CUBESIZE-1);
			int zz = (positions.charAt(i+2)-'0')&(CUBESIZE-1);

			currentState[(xx*CUBESIZE+yy)*CUBESIZE+zz]=1;
		}
    }

    /**
     *	Clears the cell array to all dead.
     */
	private void clear()
	{
		for(int i=0; i<NUMCELLS; i++)
			currentState[i]=0;

		generations = 0;
	}

    /**
     *	Loads the cell array with a random state, with approximately 25%
     *	of the cells alive.
     */
	private void loadRandomState()
	{
		patternName = "Random";

		for(int i=0; i<NUMCELLS; i++)
			currentState[i]=(rand.nextInt()>0x40000000)?(byte)1:(byte)0;

		generations = 0;
	}

    /**
     *	Handle commands.
     *	Currently, the only command enabled is "Exit" - this just
     *	destroys the MIDlet immediately.
     */
    public void commandAction(Command cmd, Displayable disp)
    {
        if (cmd == exitCommand)
        {
            try
            {
                destroyApp(false);
                notifyDestroyed();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    /**
     *	Handles key presses.
     * 	This is called back from the inner Canvas class, and implements
     *	the behavior of the various keys outlined in the class summary.
     */
    public void keyPressed(int keyCode)
	{
		switch(keyCode)
		{
			// 0,1,2,3 are speed keys.

			// 0: Pause - set a very long delay until the next update
			case Canvas.KEY_NUM0:
				delay=1000000;
				delayCount=1000000;
				break;

			// 1: Full speed - set no delay until next update
			case Canvas.KEY_NUM1:
				delay=0;
				delayCount=0;
				break;

			// 2: Speed up - if not already at full speed, decrease delay
			case Canvas.KEY_NUM2:
				if(delay>0) delay--;
				delayCount=0;
				break;

			// 3: Slow down - if not already at minimum speed, increase delay
			case Canvas.KEY_NUM3:
				if(delay<20) delay++;
				delayCount=0;
				break;

			// 4,5 are pattern keys

			// 4: Select and load previous pattern in library. If at the
			// start of the library, or using a random pattern, will start
			// again at the last pattern.
			case Canvas.KEY_NUM4:

				pattern--;

				if(pattern<0)
					pattern=patternLibrary.length -1;

				patternName = patternLibrary[pattern][0];
				loadStateFromString(patternLibrary[pattern][1]);
				break;

			// 5: Select and load next pattern in library. If at the
			// end of the library, or using a random pattern, will start
			// again at the first pattern.
			case Canvas.KEY_NUM5:
				pattern++;

				if(pattern>=patternLibrary.length)
					pattern=0;

				patternName = patternLibrary[pattern][0];
				loadStateFromString(patternLibrary[pattern][1]);
				break;

			// *: Loads a random state
			case Canvas.KEY_STAR:
				loadRandomState();
				break;
		}
	}


	/**
     * Inner TimerTask-derived class for refreshing the view.
     */
    private class RefreshTask extends TimerTask
    {
        public void run()
        {
			// Get the canvas to repaint itself.
            myCanvas.repaint();
        }
    }

    /**
     * Inner Canvas-derived class for handling canvas events.
     */
    private class CallbackCanvas extends Canvas
    {
        Life3D mymidlet;

        /**
         * Construct a new canvas
         */
        CallbackCanvas(Life3D midlet) { mymidlet = midlet; }

        /**
         * Initialize self.
         */
        void init() { }

        /**
         * Cleanup and destroy.
         */
        void destroy() { }

        /**
         * Ask mymidlet to paint itself
         */
        protected void paint(Graphics g) { mymidlet.paint(g); }

        protected void keyPressed(int keyCode) { mymidlet.keyPressed(keyCode); }
    }

	// Survival and birth parameters for individual cells.
    private static final int minSurvive = 4;
    private static final int maxSurvive = 5;
    private static final int minBirth = 5;
    private static final int maxBirth = 5;

	// The cube size must be a power of 2 for the optimised wrapping
	// code to work properly, so to ensure this, we specify the exponent
	// here. 2 to the 3 is 8, so the cube is 8x8x8.
    private static final int CUBESIZE_BITS = 3;

	// The number of cells along each edge of the cube
    private static final int CUBESIZE = (1<<CUBESIZE_BITS);

	// The total number of cells in the cube
    private static final int NUMCELLS = (CUBESIZE*CUBESIZE*CUBESIZE);

	// Various masks and values, used in the optimised update routine
    private static final int STEPX = (CUBESIZE*CUBESIZE);
    private static final int STEPY = (CUBESIZE);
    private static final int STEPZ = 1;

    private static final int MASKX = STEPX * (CUBESIZE-1);
    private static final int MASKY = STEPY * (CUBESIZE-1);
    private static final int MASKZ = STEPZ * (CUBESIZE-1);

    private static final int SHIFTX = CUBESIZE_BITS*2;
    private static final int SHIFTY = CUBESIZE_BITS;
    private static final int SHIFTZ = 0;

	// Variables.

	// Reference to the MIDlet's display
    private Display myDisplay = null;

    // Reference to the current canvas.
    private CallbackCanvas myCanvas = null;

	// Reference to a refresh timer, which is used to schedule screen updates
    private Timer myRefreshTimer = new Timer();

	// Reference to a TimerTask-derived object that calls back to the MIDlet
    private TimerTask myRefreshTask = null;

	// A command which is used to exit from the MIDlet.
    private Command exitCommand = new Command("Exit", Command.ITEM, 1);

	// Reference to the world which contains the 3D cells.
    private World myWorld = null;

	// The root group, which is the one we rotate slowly.
    private Group rootGroup = null;

	// References to the 3D objects that represent the cells,
	// one for each cell in the grid.
    private Mesh cells[];

	// Array of neighbor counts for calculating the next state,
	// one for each cell in the grid.
    private byte nextState[];

	// Array of cell states (1=alive, 0=dead), one for each cell
	// in the grid. This is not held as a boolean, so that we can
	// then use this value directly to update the number of live
	// neighbors.
    private byte currentState[];

	// Reference to a random number generator.
    private Random rand = null;
    
    // Current viewing angle. This rotates slowly.
    private float angle =0.0f;

	// Delay (number of frames) between one generation and the next.
    private int delay = 1;

    // Delay until next generation. This counts down from "delay" to 0,
	// and a new generation is calculated when it hits 0.
    private int delayCount = 0;

	// Count of number of live cells.
    private int population = 0;
    
    // Number of generations calculated since last reload.
    private int generations = 0;

	// Current pattern number from library.
	private int pattern = -1;

	// Current pattern name from library.
	private String patternName = "Random";

	// Pattern library - names and state strings for a number of interesting
	// patterns - feel free to add your own!
    private String[][] patternLibrary =
	{
		{ "L block          ", "433434443533534543",                                     },
		{ "Skew L block     ", "333334343344433444",                                     },
		{ "Opposed L block  ", "254263264353354363",                                     },

		{ "Beehive          ", "353344364355453444464455",                               },
		{ "Skew beehive     ", "323333412421423431433442521531",                         },
		{ "Broken beehive   ", "434443454535546555645646343344",                         },
		{ "Skew beehive plus", "254264345354356364366375445456466",                      },
		{ "Beehive var 75   ", "515516524525605606634635715716724725",                   },
		{ "Ascend+descend   ", "034044133143145243246256344345354355",                   },
		{ "Battered ring    ", "235244245325336354355425434446455535545",                },
		{ "Ring             ", "243253334335346343356353364365434435446456464465",       },

		{ "Cage             ", "334345455454424435433554534545543",                      },
		{ "Skew cage        ", "413422424433513514532533623",                            },

		{ "Ball             ", "326335337346425427445447526535537546",                   },
		{ "Ball 1 cap       ", "326335337346425427445447526535537546235",                },
		{ "Ball 2 caps      ", "326335337346425427445447526535537546235635",             },
		{ "Ball 2 caps hole ", "445447456416425427546526537346326335",                   },

		{ "Pinwheel         ", "213214223224303315322334413414423424",                   },

		{ "Columns          ", "445447457546556245255344346354",                         },
		{ "Columns ext      ", "445447457546556245255344346354144243043053142152",       },

		{ "Staircase        ", "462472540541561563572640641650652",                      },
		{ "Cupped hands     ", "035045134136144226234236244325335",                      },


		{ "New 1            ", "013022114113125122134133225234",                         },
		{ "New 2            ", "422423432522523544543634644643",                         },
		{ "New 3            ", "344455433435443446554555534543546",                      },
		{ "New 4            ", "111112202210213222301302310321411",                      },
		{ "New 5            ", "343353442454452545542555533644643654",                   },
		{ "New 6            ", "440450452461541550241251252340342362",                   },
		{ "New 7            ", "427434444447535536545546326335336337",                   },
		{ "New 8            ", "241250252261340341360362372450461471",                   },
		{ "New 9            ", "414415435433524525234233344343325323",                   },
		{ "New 10           ", "456466165166175176257264267274357365367",                },
		{ "New 11           ", "156165166255265266472502562571573601661663762771772",    },
		{ "New 12           ", "124125134136224226233237246336343347354356444446454455", },

		{ "Compass          ", "333432434423443533",                                     },

		{ "P2 Wonky Compass ", "344454434443445554534",                                  },
		{ "P2 Double Compass", "461462552553572573661662",                               },

		{ "P2 Blinker       ", "151161241250252260262271351361",                         },
		{ "P2 Repeater      ", "445446534536544555645646",                               },
		{ "P2 Propellor     ", "444424425436545535345334336",                            },
		{ "P2 Magic Basket  ", "344345354334446443424425436546543524525533644645655635", },

		{ "P4 Boat          ", "333334423424432435443444",                               },
		{ "P4 Rotor         ", "225235316325327335337346426436",                         },
		{ "P4 Beehive       ", "353344364355365453444464455465",                         },
		{ "P4 Shuffler      ", "356445447455466545547555566656",                         },
		{ "P4 Popper        ", "333334343344433435445454534544",                         },

		{ "P4 Glider        ", "111112121122013023010020001002",                         },
    };
}