public void findPixelChannelOrder(){
      BufferedImage image = FileController.getInstance().getImage("rsc/red.gif"); 
      int firstpixel = image.getRGB(0,0);
      int r = (firstpixel & 0xff000000) >> 16;
      int g = (firstpixel & 0x00ff0000) >> 16;
      int b = (firstpixel & 0x0000ff00) >> 16;
      int a = (firstpixel & 0x000000ff) >> 16;

      GUIController.getInstance().getConsole().print("r: "+r+" g: "+g+" b: "+b+" a: "+a);
      if (r == 255){
         EnvironmentController.getInstance().setRGBA(true);
      }else{
         if (a == 255){
            EnvironmentController.getInstance().setRGBA(false);
         }
      }
   }

// get a byte array   
imgRGBA = ((DataBufferByte)interfaceElements.get(i).image.getRaster().getDataBuffer()).getData();

//create bytebuffer            
buffer = ByteBuffer.wrap(imgRGBA);

// draw pixel            
gl.glDrawPixels(width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, buffer);

                 int width = image.getWidth();
                 int height = image.getHeight();
                
                 BufferedImage newImage = new BufferedImage(width,
                       height, BufferedImage.TYPE_4BYTE_ABGR);
              
                 for(int i = 0; i < width; i++){
                       for(int j = 0; j < height; j++){
                            int k = image.getRGB(i, j);
                            newImage.setRGB(i, j, k);
                       }
                 }      
                
           }

BufferedImage image = ImageIO.read(url);

width = image.getWidth();
height = image.getHeight();
               
gl.glWindowPos2i(win_x + 5, (win_y - height - 5));
               
byte[] imgRGBA = ((DataBufferByte)interfaceElements.get(i).image.getRaster().getDataBuffer()).getData();
ByteBuffer buffer = ByteBuffer.wrap(imgRGBA);
               
gl.glDrawPixels(width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, buffer);
               

if(olay == null){
   // create the overlay object
   olay = new Overlay(drawable);
         
   // create the java Graphics 2D Object
   g2D = olay.createGraphics();
   rec = new Rectangle();
        rec.x = 0;
        rec.y = 0;
}
      

rec.width = GLController.getInstance().getViewport()[2];
rec.height = GLController.getInstance().getViewport()[3];
      
// Create a new alpha composite 
AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER,0.75f); 

g2D.setComposite(ac); 
g2D.setColor(Color.BLACK);
g2D.fill(rec);
g2D.draw(rec);
g2D.dispose();

olay.beginRendering();
olay.draw(0,0, rec.width, rec.height);
olay.endRendering();

BufferedImage image = ImageIO.read(new File(texture));
tData = TextureIO.newTextureData(image, false);

// save in list
textureData.add(tData);

// returns the index of the saved texture data.
return textureData.size()-1;

 if(texture != -1){
    gl.glBindTexture(GL.GL_TEXTURE_2D, texture); 
    gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, 64, 64, 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE,     TextureController.getInstance().getTextureDataBufferAt(texture));
             
gl.glBindTexture(GL.GL_TEXTURE_2D, texture);
}          

gl.glEnable(GL.GL_TEXTURE_2D);
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE);
gl.glTexEnvf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
     

public void init(GLAutoDrawable drawable) {
      gl = drawable.getGL();
      
       gl.glEnable(GL.GL_DEPTH_TEST);      // Enable Depth Testing
       // Set Perspective Calculations To Most Accurate
           gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);  
       
       gl.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
       gl.glShadeModel(GL.GL_SMOOTH); // try setting this to GL_FLAT and see what happens.
      
       gl.glEnable(GL.GL_LIGHTING);
       gl.glEnable(GL.GL_LIGHT0);
       gl.glEnable(GL.GL_COLOR_MATERIAL);

    // Create light components
    float ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
    float diffuseLight[] = { 0.8f, 0.8f, 0.8f, 1.0f };
    float specularLight[] = { 0.5f, 0.5f, 0.5f, 1.0f };
    float position[] = { -1.5f, 1.0f, -4.0f, 1.0f };

    // Assign created components to GL_LIGHT0
    gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, ambientLight, 0);
    gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuseLight, 0);
    gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, specularLight, 0);
    gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, position, 0);
          
   }

   @Override
   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
      GL gl = drawable.getGL();
        GLU glu = new GLU();

        if (height <= 0) { // avoid a divide by zero error!
        
            height = 1;
        }
        final float h = (float) width / (float) height;
       
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL.GL_PROJECTION);
        
        gl.glLoadIdentity();
        
        glu.gluPerspective(45.0f, h, 1.0, 50.0);
        
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
        
        
        gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
        GLController.getInstance().setViewport(viewport);
      
   }

System.out.println("pos x = "+((0.0f - floorTileSize[0])+(float)(col*floorTileSize[0]))+"pos y = "+((0.0f - floorTileSize[1])+(float)(row*floorTileSize[1])));
             
             // start drawing in the one row and one column under the gl screen (like a safety buffer zone)
             // then add one floor tile after another till top corner is reached one row above gl screen
             gl.glTranslatef(((0.0f - floorTileSize[0])+(float)(col*floorTileSize[0])),   // x
                         ((0.0f - floorTileSize[1])+(float)(row*floorTileSize[1])),   // y
                         0.0f);                                          // z

   
// just a test check 
//gl.glTranslatef((0.0f + (float)(col*2.0f)),0.0f,0.0f);

public void display(GLAutoDrawable drawable) {
             this.gl = drawable.getGL();
        GLController.getInstance().getScene().draw(gl);
        gl.glFlush();
   }

public void draw(GL gl){
       
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT );
        gl.glLoadIdentity();

        gl.glTranslatef(0.0f, 0.0f, -25.0f);
        
        gl.glColor3f(1.0f,0.0f,0.0f);
        
        gl.glGetDoublev(GL.GL_MODELVIEW_MATRIX, modMatrix, 0);
        gl.glGetDoublev(GL.GL_PROJECTION_MATRIX, projMatrix, 0);
        gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);

...

gl.glBegin(GL.GL_TRIANGLES);
    
       for(int col = 0; col < (int)(floorDimension[0]+2); col++){
          for(int row = 0; row < (int)(floorDimension[1]+2) ; row++){
          
             gl.glPushMatrix();
             
             
             
             // start drawing in the one row and one column under the gl screen (like a safety buffer zone)
             // then add one floor tile after another till top corner is reached one row above gl screen
             gl.glTranslatef(((0.0f - floorTileSize[0])+(float)(col*floorTileSize[0])),   // x
                         ((0.0f - floorTileSize[1])+(float)(row*floorTileSize[1])),   // y
                         0.0f);                                          // z
             gl.glGetDoublev(GL.GL_MODELVIEW_MATRIX, modMatrix, 0);
             System.out.println("mod x = " + modMatrix[12] + "mod y = " + modMatrix[13] );
          
             floor.draw(gl);
             
             gl.glPopMatrix();
          }
             
       }
       
       gl.glEnd();

package network;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.DataOutputStream;
import java.io.DataInputStream;

import javax.bluetooth.DataElement;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connection;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.io.StreamConnectionNotifier;

import controller.GameController;
import controller.NetworkController;


public class Server implements Runnable{
   
   
    private LocalDevice localDevice;
   
   ServiceRecord serviceRecord;
   StreamConnection connection;
   OutputStream os;
   
   /** Describes this server */
    private static final UUID VERSUS_SERVER_UUID = 
        new UUID("F0E0D0C0B0A000908070605040302010", false);

   
    
   boolean connected = false;
   ServerReceiverThread receiver;
   
   public Server(){
      receiver = new ServerReceiverThread();
   }
   
   public void start(){
      Thread t = new Thread( this );
       // this.activeThread = t;
      t.start();
      
   }
   
   public void cancel(){
   
      Thread t = new Thread(this);
      try{
         t.sleep(1000);
         t.interrupt();
         System.out.println("server active: "+ t.isAlive());
      }catch(Exception e){
         e.printStackTrace();
      }
   
      //System.out.println(activeThread.isAlive());
   }

   
   public void run(){
       try{
        localDevice = LocalDevice.getLocalDevice();
       
        // set we are discoverable
        if (!localDevice.setDiscoverable(DiscoveryAgent.GIAC)) {
             System.out.println("not discoverable");
        }
      } catch (Exception e) {
           System.err.println("Can't initialize bluetooth: " + e);
       }
      
      StringBuffer url = new StringBuffer("btspp://");
      //createService();
       // indicate this is a server
        url.append("localhost").append(':');

        // add the UUID to identify this service
        url.append(VERSUS_SERVER_UUID.toString());

        // add the name for our service
        url.append(";name=Versus Server");

        // request all of the client not to be authorized
        // some devices fail on authorize=true
        url.append(";authorize=false");
  
      createConnection(url.toString());
   }


   public void createConnection(String url){
      try{
         StreamConnectionNotifier notifier =
             (StreamConnectionNotifier) Connector.open(url.toString());
        
          serviceRecord = localDevice.getRecord(notifier);
      
          serviceRecord.setAttributeValue(0x0100, new DataElement(DataElement.STRING, "vssrvnm"));
          serviceRecord.setAttributeValue(0x0101, new DataElement(DataElement.STRING, "test"));
      
         localDevice.updateRecord(serviceRecord);
   
        // getBTProperties();
          // accept client connections
         
          connection = notifier.acceptAndOpen();
         
          
          localDevice.setDiscoverable(DiscoveryAgent.NOT_DISCOVERABLE);
          receiver.start(connection);
          connected = true;
          os = connection.openOutputStream();
          
          String msg = "1hello there Client";
        //  os.write(msg.getBytes());
              /*
             * Here is where the gaming starts
             */
   
          startNetworkGame();
        //     connection.close();
   
      }catch(IOException e){
         e.printStackTrace();
      }
   }
   
   public void closeConnection(){
      try{
         connected = false;
          connection.close();
      
      }catch(IOException ioe){
         
      }
      
   }
   
   
   public void startNetworkGame(){
      sendCommand(GameController.getInstance().STARTGAME);
      GameController.getInstance().startGame();
   }
   
   
   public void sendCommand(int i){
      try{
         os.write(i);
      }catch(IOException e){}
         System.out.println("da geht was nicht");
      }
      
   public void sendCommand(byte[] b){
      try{
         os.write(b);
      }catch(IOException e){}
   }
   
   

   public void getBTProperties(){
      System.out.println(NetworkController.getInstance().getConnectionManager().getLocalDevice().getProperty("bluetooth.api.version"));
      System.out.println(NetworkController.getInstance().getConnectionManager().getLocalDevice().getProperty("bluetooth.sd.attr.retrievable.max"));
      System.out.println(NetworkController.getInstance().getConnectionManager().getLocalDevice().getProperty("bluetooth.connected.devices.max"));
      System.out.println(NetworkController.getInstance().getConnectionManager().getLocalDevice().getProperty("bluetooth.connected.inquiry.scan"));
      System.out.println(NetworkController.getInstance().getConnectionManager().getLocalDevice().getProperty("bluetooth.api.version"));
      System.out.println(NetworkController.getInstance().getConnectionManager().getLocalDevice().getProperty("bluetooth.connected.inquiry"));
   }
   

}

class ServerReceiverThread implements Runnable{
      boolean connected;
      StreamConnection connection;
   
      public ServerReceiverThread(){}
      
   public void start(StreamConnection c) {
      this.connection = c;
      this.connected = true;
      Thread t = new Thread(this);
      t.start();
   }

   public void run() {
      try {
         InputStream is = connection.openInputStream();
         byte[]buffer = new byte[100];
         
         while (connected) {
            is.read(buffer);
            NetworkController.getInstance().seh.handleIncomingBytes(buffer);
            }
         
         
      } catch (IOException ioe) {

      }

   }
   

   
}

package network;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.util.Vector;

import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.io.StreamConnectionNotifier;

import controller.GameController;
import controller.NetworkController;

public class Client implements Runnable, DiscoveryListener{
   
   
   /**save the discoveres Devices*/
   Vector remoteDevices = new Vector();
   
   
    /** Describes this server */
    private static final UUID VERSUS_SERVER_UUID = 
        new UUID("F0E0D0C0B0A000908070605040302010", false);
   
   /** Optimization: keeps service search patern. */
    private UUID[] uuidSet;
    
   //UUID[] uuidSet = {new UUID(0x0003) };
   int[] attributes = {0x0100, 0x0101, 0x0003, 0x0004, 0x0000};
   
   Thread clientThread;

   
   LocalDevice localDevice;
   DiscoveryAgent discoveryAgent;
   
   boolean testBT;

    /** Keeps the device discovery return code. */
    private int discType;
   
   
    /**
     * Connection spezified stuff
     */
   String connectionURL;
   
   /** connection*/
   StreamConnection connection;
   
   /**write*/
   OutputStream os;
   
   /**read*/
   InputStream is;
   
   ClientReceiverThread receiver;
   boolean connected = false;
   
   
   
   public Client(){
      receiver = new ClientReceiverThread();
   }
   
   
   
   public void start(){
      NetworkController.getInstance().setClientBusy(true);
      clientThread = new Thread( this );
      clientThread.start();
   }
   
   
   
   public void run(){
      
      try{
         
          // initialize bluetooth first
        
         
         // create/get a local device and discovery agent
         localDevice = LocalDevice.getLocalDevice();
         discoveryAgent = localDevice.getDiscoveryAgent();
         
          // remember we've reached this point.
    
            
      }catch(BluetoothStateException e){}
      
      //initialize some optional variables
      uuidSet = new UUID[2];
        // ok, we are interesting in btspp services only
       uuidSet[0] = new UUID(0x1101);

       // and only known ones, that allows pictures
       uuidSet[1] = VERSUS_SERVER_UUID;
      
      
       remoteDevices.removeAllElements();
       //Ok now we can search for Devices..
   
       searchDevices();
   
      if(remoteDevices.size() > 0){
         
          searchServices();
      }else {
          System.out.println("no Device found");
      }
       
    try{ 
       // notified by notifyConnection() when trying to connect to Server..
         synchronized(this){
            wait();
         }
       
      } catch(InterruptedException e){
         
      }
      connectionURL = (String)NetworkController.getInstance().getRemoteConnectionURLs().firstElement();
      System.out.println("url: "+connectionURL.toString());
      enterConnection(connectionURL);
   }

   public void searchDevices() {
   
      try {
      
          
      
         // To start searching for Bluetooth-enabled phones, use the DiscoveryAgent
         discoveryAgent.startInquiry(DiscoveryAgent.GIAC, this);
         System.out.println("searching for Devices...");
      } catch (BluetoothStateException e) {
         e.printStackTrace();
      }
      
       try {
          synchronized(this){
          // until devices are found
            wait(); 
          }
            
           } catch (InterruptedException e) {
               System.err.println("Unexpected interuption: " + e);
           }
           
           System.out.println("search Device komplett");

   }
   
   
    /**
     * Invoked by system when a new remote device is found -
     * remember the found device.
     */
   public void deviceDiscovered(RemoteDevice remoteDevice, DeviceClass cod) {
      System.out.println("device discoverd...");
      try {
         
         remoteDevices.addElement(remoteDevice);
      
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
   
   
   
   /**
     * Invoked by system when device discovery is done.
     * <p>
     * Use a trick here - just remember the discType
     * and process its evaluation in another thread.
     */
    public void inquiryCompleted(int discType) {
        this.discType = discType;
     
        synchronized(this){
            notify();
            System.out.println("search Device notify");
        }
    }
    
    public void searchServices(){
       try {
   
         for ( int i = 0; i < remoteDevices.size(); i++) {
            discoveryAgent.searchServices(attributes, uuidSet,
                  (RemoteDevice) remoteDevices.elementAt(i), this);
         }
         
      } catch (BluetoothStateException e) {
         e.printStackTrace();
      }
    }
    
    
    public void servicesDiscovered(int transID, ServiceRecord[] serviceRecord) {
      try {

         /*
          * Wenn das Versus aktiv ist versendet bluetooth die Versus ID:
          * vssrvnm dadurch werden nur entsprächende ServiceRecords
          * gefiltert, die auf die man zugreifen soll
          */
      
         // TODO:else anweisung für DEBUG nachher rausnehmen
         if (serviceRecord[0].getAttributeValue(0x100).getValue().toString()
               .equals("vssrvnm")) {
            /*
             * Gefundene Versus Services werden dem Networkcontroller
             * übergeben.
             */
            System.out.println("Versus Server gefunden...");
         
            NetworkController.getInstance().addServiceRecords(serviceRecord[0]);
            NetworkController.getInstance().setServiceDiscovered(true);
            
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
    
   public void serviceSearchCompleted(int arg0, int arg1) {
      // TODO Auto-generated method stub
      NetworkController.getInstance().setClientBusy(false);
      NetworkController.getInstance().updateServerList();
      NetworkController.getInstance().drawServerList();
      System.out.println("service search completed: list updated...");

   }

   
   public void enterConnection(String URL){
      
      
      
      try {
//          open a connection to the server
         connection = (StreamConnection)Connector.open(URL);
         System.out.println(connection.toString());
       } catch (IOException e) {
             System.err.println("Note: can't connect to: " + URL);
       }
       try{
         connected = true;
         //          Send/receive data
         byte[]buffer = new byte[100];
         System.out.println("bevore method receive bytes client");
         
         
         receiver.start(connection);
         os = connection.openOutputStream();
      
          String msg = "1hello there";
        //  InputStream is = connection.openInputStream();
        
          
           
          // send data to the server
          os.write(msg.getBytes());
          
          // read data from the server
      
          /*
           *     is.read(buffer);
      
            String text = new String(buffer);
           System.out.println(text);
           */
      
          
             /*
             * Here is where the game starts
             */
           
           
          
           
           //closeConnection();
           
      } catch(Exception e) {
        e.printStackTrace(); 
      }
      
   }
   
   public void sendCommand(int i){
      try{
         os.write(i);
      }catch(IOException e){
         
      }
   }
   
   public void sendCommand(byte[] b){
      try{
         os.write(b);
      }catch(IOException e){
         
      }
   }
   /*
    * falls man die funktion als thread laufen lassen kann receiveBytes verwenden anstatt classe receiver
    */
   public void receiveBytes(StreamConnection connection){
         
        byte buffer[] = new byte[100];
      try{
         
         InputStream is = connection.openInputStream();
         while(connected){
            is.read(buffer);
            NetworkController.getInstance().ceh.handleIncomingBytes(buffer);
            System.out.println("received");
         }
      }catch(IOException e){
         e.printStackTrace();
      }
      
   }
   
   public void closeConnection(){
      try{
         connected = false;
          connection.close();
      }catch(IOException ioe){
      
            
      }
   }



   public LocalDevice getLocalDevice() {
      return localDevice;
   }
   
   public void notifyConnection(){
      synchronized(this){
         notify();
      }
   }

}


/**
 * 
 * @author Admin
 *   ClientReceiverThread: Class for listening to incoming Events
 */

class ClientReceiverThread implements Runnable{
   boolean connected;
   StreamConnection connection;

   public ClientReceiverThread(){}
   
public void start(StreamConnection c) {
   this.connection = c;
   this.connected = true;
   Thread t = new Thread(this);
   t.start();
}

public void run() {
   try {
      InputStream is = connection.openInputStream();
      byte[]buffer = new byte[100];
      
      while (connected) {
         is.read(buffer);
         NetworkController.getInstance().ceh.handleIncomingBytes(buffer);
         }
      
      
   } catch (IOException ioe) {

   }

}
}

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class HelloMIDlet extends MIDlet 
       implements CommandListener {
 
  // The display for this MIDlet
   private Display display;    
   


  //private VSGameCanvas canvas;
  private MyCanvas mycanvas;
  public HelloMIDlet() {
     
     display = Display.getDisplay(this);
     mycanvas = new MyCanvas();
   //  canvas = new VSGameCanvas(true);
  }

  public void startApp() {
   
  //  Display.getDisplay(this).setCurrent(mMainForm);
     display.setCurrent(mycanvas);
   //  display.setCurrent(mMainForm);
   // mycanvas.setFullScreenMode(true);
    mycanvas.repaint();
   
  }
  public void pauseApp() { }
  public void destroyApp(boolean unconditional) { }
  public void commandAction(Command c, Displayable s) {
   // if (c == exitCommand) {
    //  destroyApp(false);
      notifyDestroyed();
   // }
  }
}

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;



public class MyCanvas extends Canvas{
   Image bgImage;
   public MyCanvas(){   }
   protected void paint(Graphics g) {
      
      try{
         bgImage = Image.createImage("/grassland.png");
      }catch (Exception e){
            e.printStackTrace();
            g.drawString(e.toString(),0,0,0);
   
         };
         
         g.drawImage(bgImage, 0, 0, 0);
         
   }

      
}

public void draw(GLDrawable drawable){
      GL gl = drawable.getGL();

      gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
      
      gl.glMatrixMode(GL.GL_MODELVIEW);   
               gl.glLoadIdentity();
   
           double[] mvMatrix = new double[16];
          double[] projection = new double[16];
          int[] viewport = new int[4];
          double[] objx = new double[1];
          double[] objy = new double[1];
          double[] objz = new double[1];
          int realY;
          gl.glGetDoublev(GL.GL_MODELVIEW, mvMatrix);
          for (int i = 0; i < mvMatrix.length; i++){
             System.out.println("mvmatrix: "+mvMatrix[i]);
          }
          gl.glGetDoublev(GL.GL_PROJECTION, projection);
          gl.glGetIntegerv(GL.GL_VIEWPORT, viewport);
          realY = viewport[3] - mouseY - 1 ;
          glu.gluUnProject((double)mouseX, (double)realY, 0.0, mvMatrix, projection, viewport, objx, objy, objz);
          
          System.out.println("this is it: "+objx[0]+","+objy[0]+","+objz[0]);
          
      // drawing just a cube
            this.geoobj.drawFromPrimitives();
         
      
      gl.glFlush();
   
   }

 public void vertexFeedbackMode(Vertex v){
      //System.out.println("start vertexFeedbackMode()");
      FloatBuffer feedbackBuffer = BufferUtils.newFloatBuffer(1024);
      int size;
      
      Vertex vertex = v;
      
      gl.glFeedbackBuffer(1024, GL.GL_3D, feedbackBuffer);
      gl.glMatrixMode(GL.GL_PROJECTION);
      gl.glPushMatrix();
   
      gl.glRenderMode(GL.GL_FEEDBACK);
      gl.glLoadIdentity();
      

               // glu.gluPerspective(45.0,this.h, 1.0, 20.0);
      
      gl.glOrtho(0.0,(double)screenwidth,0.0,(double)screenheight,-1.0, 1.0);

      //
   //   gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   //   gl.glClear(GL.GL_COLOR_BUFFER_BIT);
   
       

      //gl.glTranslatef(0.0f, 0.0f, -6.0f); 
   
      
      gl.glPassThrough(1.0f);
      
      gl.glBegin(GL.GL_POINTS);
        gl.glVertex3f(vertex.data[0],vertex.data[1], vertex.data[2]);   
        gl.glEnd();
        
      size = gl.glRenderMode(GL.GL_RENDER);
   
      printOutFeedback(size, feedbackBuffer);
       gl.glMatrixMode(GL.GL_PROJECTION);
           gl.glPopMatrix();
           gl.glMatrixMode(GL.GL_MODELVIEW);
           gl.glLoadIdentity();
      //System.out.println("end vertexFeedbackMode()");
    }