glBindTexture(GL2.GL_TEXTURE_2D, WWV.tex_handles[LODLevel]);
      glBindBuffer(GL2.GL_ARRAY_BUFFER, vbo_handle);
      
      glVertexPointer(3, GL2.GL_FLOAT, 5 * 4, 0);
      glTexCoordPointer(2, GL2.GL_FLOAT, 5 * 4, 3 * 4);

      glDrawArrays(GL2.GL_TRIANGLES, 0, Buffer.capacity() / 5);

void renderBuffer() {
      
      glBindTexture(GL2.GL_TEXTURE_2D, WWV.tex_handles[LODLevel]);   //It's not the texture, that's almost guaranteed
      glBindBuffer(GL.GL_ARRAY_BUFFER, vbo_handle);               //The VBO Handle is good as well (see glGetBufferSubData below)
      
      System.out.print("Rendering Chunk   " + start_x + "   " + start_y + "   " + start_z);
      System.out.println("   vbo_handle:   " + vbo_handle + "   Buffer.capacity():   " + Buffer.capacity() + "   WWV.tex_handles[LODLevel]:   " + WWV.tex_handles[LODLevel]);
         
      Buffer.clear();
         
      glGetBufferSubData(GL.GL_ARRAY_BUFFER, 0, Buffer.capacity()*4, Buffer);
         
      for (int i = 0; i < Buffer.capacity(); i++) {
         System.out.print(Buffer.get(i) + " ");
      }
      System.out.println();

      glVertexPointer(3, GL.GL_FLOAT, 5 * 4, 0);
      glTexCoordPointer(2, GL.GL_FLOAT, 5 * 4, 3 * 4);
      
      System.out.println("Before drawing");
      glDrawArrays(GL.GL_TRIANGLES, 0, Buffer.capacity() / 5);
      
      System.out.println("Done");
   }

glLoadIdentity();

glEnableClientState(GL.GL_POINTS); 
glPointSize(25);
        
glBegin(GL.GL_POINTS);     //Instead of POINTS render an object here
glVertex3d(0, 0, -1);  
glEnd();

glDisableClientState(GL.GL_POINTS); 

glPushMatrix();

glLoadIdentity();
gluLookAt(pos.x, pos.y, pos.z, lookat.x, lookat.y, lookat.z, 0, 1, 0);
      
      glTranslated(x, y, z);
      glRotated(rot_x, 1, 0, 0);
      glRotated(rot_y, 0, 1, 0);
      glRotated(rot_z, 0, 0, 1);
      
      //Actual call to glDrawArrays or similar
      
      glPopMatrix();

rot_x = Math.abs(Math.cos(viewangle_horizontal))*180;
rot_z = Math.abs(Math.sin(viewangle_horizontal))*180;

public Main() {
      super("");
      //
      GLProfile glp = GLProfile.get(GLProfile.GL2);
      caps = new GLCapabilities(glp);
      canvas = new GLCanvas(caps);

      canvas.addGLEventListener(render_VBO);
      canvas.addKeyListener(render_VBO);
      canvas.addMouseListener(render_VBO);
      canvas.addMouseMotionListener(render_VBO);

      getContentPane().add(canvas);

      setResizable(false);
      // setSize(1920, 1080);

      if (!isDisplayable())
         setUndecorated(true);
      setExtendedState(JFrame.MAXIMIZED_BOTH);
      // TODO: True Fullscreen
      // GraphicsDevice gd =
      // GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
      // gd.setFullScreenWindow(this);

      //Make Cursor Invisible
      Toolkit tk = Toolkit.getDefaultToolkit();
      Image image = tk.createImage("");
      Point point = new Point(0, 0);
      Cursor cursor = tk.createCustomCursor(image, point, "");
      setCursor(cursor);

      setVisible(true);
      canvas.requestFocus();
      canvas.requestFocusInWindow();

      FPSAnimator animator = new FPSAnimator(canvas, 1000);
      animator.add(canvas);
      animator.start();
   }

   public void display(GLAutoDrawable drawable) {

      Now = System.nanoTime();
      MSSinceLastFrame = (double) (Now - LastCall) / 1000000;
      LastCall = Now;
      System.out.println("MS since last call:   " + MSSinceLastFrame + "   FPS:   " + 1000/MSSinceLastFrame);

      do_look();                                  //Adjusts lookatx, lookaty, lookatz

      do_move(MSSinceLastFrame);        //Adjusts posx, posy, posz
      
      GL2 currGL = drawable.getGL().getGL2();
      
      currGL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);   //Reset
                currGL.glLoadIdentity();
      glu.gluLookAt(posx, posy, posz, lookatx, lookaty, lookatz, 0, 1, 0);          //Player position and direction

      currGL.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo_handle);
      
      currGL.glEnableClientState(GL2.GL_VERTEX_ARRAY);
      currGL.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);  
      currGL.glEnable(GL.GL_TEXTURE_2D);     
      
      currGL.glBindTexture(GL.GL_TEXTURE_2D, texture.getTextureObject(currGL));

      currGL.glVertexPointer(3, GL.GL_FLOAT, 5 * 4, 0);                     //Each Vertex has 3 Coords...
      currGL.glTexCoordPointer(2, GL.GL_FLOAT, 5 * 4, 3 * 4);            //... and 2 Texture Coordinates, packed interleaving
      
      currGL.glDrawArrays(GL.GL_TRIANGLES, 0, 4 * Buffer.capacity()); //Render the whole Buffer

      currGL.glDisableClientState(GL2.GL_VERTEX_ARRAY);
      currGL.glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY);  

      currGL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
      currGL.glBindTexture(GL.GL_TEXTURE_2D, 0);
      
      double tmp = System.nanoTime();
      double mspassedwhilerendering = (tmp - LastCall) / 1000000;
      System.out.println("MS Passed on CPU:   " + mspassedwhilerendering + "   FPS (CPU):   " + 1000/mspassedwhilerendering);

      currGL.glFinish();
      drawable.swapBuffers();

@Override
   public void init(GLAutoDrawable drawable) {
      drawable.setAutoSwapBufferMode(false);
      
      GL2 gl = drawable.getGL().getGL2();
      glu = new GLU();
      gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      gl.glClearDepth(1.0f);
      gl.glShadeModel(GL2.GL_SMOOTH);
      gl.glEnable(GL.GL_DEPTH_TEST);
      gl.glDepthFunc(GL.GL_LEQUAL);
      gl.glEnable(GL.GL_TEXTURE_2D);

      // reshape
      glu.gluLookAt(posx, posy, posz, lookatx, lookaty, lookatz, 0, 1, 0);
      glu.gluPerspective(45.0, SCREEN_WIDTH / SCREEN_HEIGHT, 1, 100);
      // fov, aspect ratio, near & far clipping planes
      
      if (vbo_handle <= 0) {
         int[] tmp = new int[1];
                        gl.glGenBuffers(1, tmp, 0);
                        vbo_handle = tmp[0];
                }
      Buffer = Buffers.newDirectFloatBuffer(90*65536);   //==65k Cubes == 6M Floats == 24 MBytes
      
      int numBytes = Buffer.capacity() * 4;// Allocate the Buffer (Data is set on a per-Octree-Leaf basis!)
                gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo_handle);
                gl.glBufferData(GL.GL_ARRAY_BUFFER, numBytes, null, GL.GL_DYNAMIC_DRAW);
                gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
   }

int numBytes = 30 * 3 * cubes * 4;            //cubes < 512 in every case (this is performed in the Leaf of the Octree)
WWV.gl.glBindBuffer(GL.GL_ARRAY_BUFFER, WWV.vbo_handle);
WWV.gl.glBufferSubData(GL.GL_ARRAY_BUFFER, myPos * 4, numBytes, WWV.Buffer);
WWV.gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);