public void rebuild(View view) {

      view.getTransform().get(pTemp); // get the location of the view
      terrain.update(pTemp,117); // update terrain according to the views location
      
      for(int row=0; row<geo.length; ++row){
        for(int col=0; col<geo[0].length; ++col){
        
          geo[row][col].drawStart(); // resets the terrain vertices
          totalIndex = totalVerts = 0;
          terrain.render(this);
          geo[row][col].drawEnd(); // commits the changes to the video card
          geo[row][col].setIndex(index);

          geo[row][col].setValidIndexCount(totalIndex);
          geo[row][col].setValidVertexCount(totalVerts);
          
        }
      }

    }// end rebuild()

    /** called at the beginning of rendering the triangles for one adaptive quad square
     */
    public void start() {
    }
    
    /** */
    public void initVert(int i, float x, float y, float z) {
      
      //System.out.println("initVert: x:"+x+" y:"+y+" z:"+z);
      //System.out.println("texture scale: "+textureScale);
      
      if (totalVerts>=MAX_VERTICES) return;
      
      int row = (int)((x) / 256);
      int col = (int)((z) / 256);
      
      if(row == 4)row = 3;
      if(col == 4)col = 3;
      
      //System.out.println("row: "+row);
      //System.out.println("col: "+col);
      
      //for(int row=0; row<geo.length; ++row){
        //for(int col=0; col<geo[0].length; ++col){
          
          geo[row][col].newVertex();
          geo[row][col].setCoordinate(x,y,z);

          /**
           * Next we have to divide out the texture coordinates. 2D textures have coordinates
           * from 0 to 1 in what is called "S,T" space. Each coordinate in our X,Z world
           * has to be mapped to its appropriate S,T texture coordinate. If we are stretching
           * the texture all the way across the terrain, then 0,0 in X,Z would be 0,0 in S,T and
           * the farthest point in X,Z from the origin would be 1,1 in S,T. Thus, mathematically,
           * we should divide X and Z by the width and depth (should be equal) of the terrain. To
           * wrap the texture, you would divide this depth and width by some number (set by textureScale)
           * to make the textured patches smaller.
          */
          float texCoordx = x / (terrain.getWidth() / textureScale);
          float texCoordz = z / (terrain.getWidth() / textureScale);
          // Now we need to use these figures to set up a TexCoord2f
          TexCoord2f texCoords = new TexCoord2f(texCoordx, texCoordz);
       
          geo[row][col].setTextureCoordinate(0,totalVerts,texCoords);

          // We want prettier colors :-)
          float c = y/1500;
          geo[row][col].setColor(0.48f+c, 0.48f+c, 0.39f+c);

          vertexMap[i] = totalVerts++;
          
        //}
      //}// end for loop

    }// initVert()

    /** */
    public void tri(int a, int b, int c) {
      
      if (totalIndex+3>=MAX_INDICES) return;
      index[totalIndex++] = vertexMap[a];
      index[totalIndex++] = vertexMap[b];
      index[totalIndex++] = vertexMap[c];
      
    }// end tri()

Examining file : META-INF/
Examining file : META-INF/MANIFEST.MF
Examining file : net/
Examining file : net/java/
Examining file : net/java/games/
Examining file : net/java/games/input/
Examining file : net/java/games/input/DirectInputAxis.class 

C:\jinput>java -cp jutils.jar;jinput.jar -Djava.library.path=. net.java.games.in
put.test.ControllerReadTest

-Djava.library.path=. -Djinput.plugins=net.java.games.input.DirectInputEnvironmentPlugin

{java_home}/jre/libs/ext directory

/*
 * InputManager.java
 *
 * Created on 10 January 2005, 19:04
 */

import net.java.games.input.*;

/**
 *
 * @author Preacher
 */
public class InputManager {
  
  Keyboard kb = null;
  
  public static void main(String[] args){
    new InputManager();
  }
  
  /** Creates a new instance of InputManager */
  public InputManager() {
    
    ControllerEnvironment ce = ControllerEnvironment.getDefaultEnvironment();
    Controller[] cont = ce.getControllers();
 
    System.out.println("cont: " + cont.length);
     for (int i = 0; i < cont.length; i++) {
       if (cont[i].getType() == cont[i].getType().KEYBOARD) {
         kb = (Keyboard) cont[i];
      }
    }
    
    for(int i = 0; i < 100000; i++) {
      update();
    }
    
    System.out.println("done..."); 
    
  }// end constructor
  
  public void update(){
    
    kb.poll();
    
    Axis[] ax = kb.getAxes();
    
    for (int x = 0; x < ax.length; x++) {
      float num = ax[x].getPollData();
      if (num != ax[x].getDeadZone()) {
        if (ax[x].getName().equalsIgnoreCase("key 110")) {
          System.out.println("up arrow");
        }
      }
    } 
    
  }
  
}// end class 

java -cp jinput.jar;jutils.jar net.java.games.input.test.ControllerReadTest

C:\Program Files\Java\jdk1.5.0_01\jre\lib\ext>java -cp jinput.jar;jutils.jar net
.java.games.input.test.ControllerTextTest
Controller Env = net.java.games.input.DefaultControllerEnvironment@35ce36
Scanning jar: dxinput.jar
Examining file : META-INF/
Examining file : META-INF/MANIFEST.MF
Examining file : net/
Examining file : net/java/
Examining file : net/java/games/
Examining file : net/java/games/input/
Examining file : net/java/games/input/DirectInputAxis.class
Examining file : net/java/games/input/DirectInputDevice.class
Examining file : net/java/games/input/DirectInputEnvironmentPlugin.class
Found candidate class: net/java/games/input/DirectInputEnvironmentPlugin.class
Exception in thread "main" java.lang.NoClassDefFoundError: IllegalName: net/java
/games/input/DirectInputEnvironmentPlugin
        at java.lang.ClassLoader.preDefineClass(Unknown Source)
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$100(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at net.java.games.util.plugins.Plugins.processJar(Plugins.java:112)
        at net.java.games.util.plugins.Plugins.scanPlugins(Plugins.java:85)
        at net.java.games.util.plugins.Plugins.<init>(Plugins.java:73)
        at net.java.games.input.DefaultControllerEnvironment.scanControllersAt(D
efaultControllerEnvironment.java:174)
        at net.java.games.input.DefaultControllerEnvironment.scanControllers(Def
aultControllerEnvironment.java:164)
        at net.java.games.input.DefaultControllerEnvironment.access$000(DefaultC
ontrollerEnvironment.java:57)
        at net.java.games.input.DefaultControllerEnvironment$1.run(DefaultContro
llerEnvironment.java:108)
        at java.security.AccessController.doPrivileged(Native Method)
        at net.java.games.input.DefaultControllerEnvironment.getControllers(Defa
ultControllerEnvironment.java:106)
        at net.java.games.input.test.ControllerTextTest.<init>(ControllerTextTes
t.java:54)
        at net.java.games.input.test.ControllerTextTest.main(ControllerTextTest.
java:86)

public class SingletonExample{

  private static SingletonExample sinEx = new SingletonExample();

  private SingletonExample(){
    
  }

  public SingletonExample getReference(){
    return sinEx;
  }

}

private EmergeAnt(){
            
            System.out.println("EmergeAnt: Brian Heylin ITCarlow 2004");
            
    setFramePerSecond(30);
    
            userInterface = UserInterface.getReference();
            
    run();
    
    System.out.println("Loop Variables");
    System.out.println("Number Loops = " + numLoop);
    System.out.println("Number Sleeps = " + numSleep);
    System.out.println("Number Overworked = " + numOverWorked);
    System.out.println("Number Yields = " + numYield);
            
      }// end constructor EmergeAnt()
      
  /** Contains the driver loop 
   *  This loop dynamically adjusts itself for the best performance without
   *  comprimising the UserInterface update rate
   */
  private void run(){
    
    beforeTime = System.nanoTime(); // get absolute time before loop runs
    running = true;
    
    while(running){
      
      ++numLoop;
      /** perform updating of ai and ui etc. here*/
      userInterface.update();
   
      afterTime = System.nanoTime(); // get absolute time after udating finished
      timeDiff = afterTime - beforeTime;
      // check if the time available (period) was enough for the workload to complete
      sleepTime = (period - timeDiff) - overSleepTime;
       
      //  if the workload was low, we can afford to sleep and let other threads 
      //  execute
      if(sleepTime > 0){
               
        try{
          Thread.sleep(sleepTime/2000000L); // nano -> milli
        }catch(InterruptedException ex){}
        
        // due to sleep() method tendancy to sleep over the requested time
        // calc the acual time slept and compensate on next loop 
        overSleepTime = (System.nanoTime() - afterTime) - sleepTime;

      }else{ // The workload was too much for period
        
        excess -= sleepTime;
        overSleepTime = 0L;
        
        if(++numberDelays >= NUM_DELAYS_PER_YIELD){
          Thread.yield();
          numberDelays = 0;
        }
        
      }// end sleepTime check
      
      beforeTime = System.nanoTime(); // update the time
    }
  }// end run()

public class InfoWindow extends UIWindow{
      
      private UIWindowManager windowMgr = null;
      private JPanel root = null;
      private InfoCanvas infoCanvas = new InfoCanvas();
      
      public InfoWindow(Canvas3D canvas){
            
            super(210, 110, true, false);
            windowMgr = new UIWindowManager(canvas);
            
            root = new JPanel(true);
            root.setSize(210, 110); 
            root.setOpaque(false);
            root.add(infoCanvas);
            
            windowMgr.addOverlay(this);
            setRoot(root);
                  
      }
      
      /**
   * 
   */
      public synchronized void update(){
            
            super.update();
            setRoot(root);
            
      }
      
      /**
   * 
   */
      public synchronized void setMessage(String message){
            
            infoCanvas.message = message;
            
      }
      
      /**
   * 
   */
      public synchronized void setLocation(Point location){
            
            System.out.println ("Setting info window location");
            windowMgr.setPosition(this, location.x, location.y);
            
      }
      
      public synchronized void setVisible(boolean isVisible){
            
            System.out.println ("Setting info window visible");
            windowMgr.setVisible(this, isVisible);      
            
      }
      
      /**
   * 
   */
      private class InfoCanvas extends Canvas{
            
            public String message = "";
            
            public InfoCanvas(){
                  setBounds(0, 0, 200, 100);
                  setVisible(true);
            }
            
            /**
         * 
         */
            public void paint(Graphics g){
                  
                  System.out.println ("Painting InfoWindow");
                  
                  Graphics2D g2d = (Graphics2D)g;
                  
                  g2d.setPaint(new Color(0.15f, 0.0f, 0.60f));
                  g2d.fillRoundRect(0, 0, 200, 100, 20, 20);
                  g2d.setPaint(new Color(0.25f, 0.0f, 0.70f));
                  g2d.fillRoundRect(5, 5, 190, 90, 20, 20);
                  
                  g2d.setPaint(new Color(0.8f, 0.6f, 0.9f));
                  g2d.drawString(message , 10, 50);
                  
            }      
      }      
}

float cos = (float)Math.cos(rotXDisplacement);
            float x = cos*(float)Math.cos(rotYDisplacement) * zoomDisplacement;
            float y =                  (float)Math.sin(rotXDisplacement) * zoomDisplacement;
            float z = cos*(float)Math.sin(rotYDisplacement) * zoomDisplacement; 
            
            view.getTransform().lookAt(new Vector3f( x, y, z),  // location of eye
                                 centerVector,                           // center of view
                                 upVector);