Problem of visualization during intersection of surfaces

[andretti]

Hi, i've coded an algorithm to generate a terrain surface. I store all the height values in a matrix and then, using GL_QUADS, i draw the surface. And everything is ok. The problem comes when i draw a simple and stupid box to simulate water level: when the two surfaces (water and terrain) intersect, i come into problem of visualization. Sometimes i can see regions that should be underwater! And only by changing the viewing angle i can see or not see the water! Sorry, but my english is poor and i don't know exactly how to explain the effect! Then i made an experiment: i draw two rectangles ortogonal and make them intersect and i see the same problem of visualization: the intersection of the two object always produce a strange effect similar to a flickering or a distorsion, not a perfect intersection. I post the initialization code (base on NeHe's tut) and the render method. I think this is a problem of Depth testing but i don't know how to solve it. Can somebody help me? Thank you a lot.

private void initGL() {
      GL11.glEnable(GL11.GL_TEXTURE_2D); // Enable Texture Mapping
      GL11.glShadeModel(GL11.GL_SMOOTH); // Enable Smooth Shading
      GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.9f); // Black Background
      GL11.glClearDepth(1.0f); // Depth Buffer Setup
      GL11.glEnable(GL11.GL_DEPTH_TEST); // Enables Depth Testing
      GL11.glDepthFunc(GL11.GL_LEQUAL); // The Type Of Depth Testing To Do

      GL11.glMatrixMode(GL11.GL_PROJECTION); // Select The Projection Matrix
      GL11.glLoadIdentity(); // Reset The Projection Matrix

      // Calculate The Aspect Ratio Of The Window
      GLU.gluPerspective(45.0f, (float) displayMode.getWidth() / (float) displayMode.getWidth(),0.1f,400.0f);
      GL11.glMatrixMode(GL11.GL_MODELVIEW); // Select The Modelview Matrix

      // Really Nice Perspective Calculations
      GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
      ByteBuffer temp = ByteBuffer.allocateDirect(16);
      temp.order(ByteOrder.nativeOrder());
      GL11.glLight(GL11.GL_LIGHT1, GL11.GL_AMBIENT, (FloatBuffer)temp.asFloatBuffer().put(lightAmbient).flip());              // Setup The Ambient Light
      GL11.glLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, (FloatBuffer)temp.asFloatBuffer().put(lightDiffuse).flip());              // Setup The Diffuse Light
      GL11.glLight(GL11.GL_LIGHT1, GL11.GL_POSITION,(FloatBuffer)temp.asFloatBuffer().put(lightPosition).flip());         // Position The Light
      GL11.glEnable(GL11.GL_LIGHT1);                          // Enable Light One
  }


private boolean render() {
      GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);          // Clear The Screen And The Depth Buffer

      GL11.glLoadIdentity();                          // Reset The Current Modelview Matrix

      GL11.glTranslatef(-10.0f,-10.0f,z);                     // Translate Into/Out Of The Screen By z

      GL11.glRotatef(xrot,1.0f,0.0f,0.0f);                        // Rotate On The X Axis By xrot
      GL11.glRotatef(yrot,0.0f,1.0f,0.0f);                        // Rotate On The Y Axis By yrot
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture[filter]);                // Select A Texture Based On filter

      if (sea) {
      GL11.glBegin(GL11.GL_QUADS);                            // Start Drawing the sea rectangle in beautiful blue!
             GL11.glColor3f(0.313f,0.313f,0.902f);
             //Disegno livello del mare
             GL11.glNormal3f( 0.0f, -1.0f, 0.0f);
             GL11.glVertex3f(0f,0f,0f);
             GL11.glVertex3f(0f,0f,(float)(latoMondo));
             GL11.glVertex3f((float)(latoMondo),0f,(float)(latoMondo));
             GL11.glVertex3f((float)(latoMondo),0f,0f);
           
             GL11.glNormal3f( 0.0f, 1.0f, 0.0f);


             GL11.glVertex3f(0f,(livelloMare*normalFactor),0f);
            GL11.glVertex3f(0f,(livelloMare*normalFactor),(float)(latoMondo));
            GL11.glVertex3f((float)(latoMondo),(livelloMare*normalFactor),(float)(latoMondo));
             GL11.glVertex3f((float)(latoMondo),(livelloMare*normalFactor),0f);

             GL11.glNormal3f( -1.0f, 0.0f, 0.0f);
             GL11.glVertex3f(0f,0f,0f);
            GL11.glVertex3f(0f,0f,(float)(latoMondo));
            GL11.glVertex3f(0f,(livelloMare*normalFactor),(float)(latoMondo));
             GL11.glVertex3f(0f,(livelloMare*normalFactor),0f);

             GL11.glNormal3f( 1.0f, 0.0f, 0.0f);
             GL11.glVertex3f((float)(latoMondo),0f,0f);
            GL11.glVertex3f((float)(latoMondo),0f,(float)(latoMondo));
            GL11.glVertex3f((float)(latoMondo),(livelloMare*normalFactor),(float)(latoMondo));
             GL11.glVertex3f((float)(latoMondo),(livelloMare*normalFactor),0f);

             GL11.glNormal3f( 0.0f, 0.0f, -1.0f);
             GL11.glVertex3f(0f,0f,0f);
            GL11.glVertex3f((float)(latoMondo),0f,0f);
            GL11.glVertex3f((float)(latoMondo),(livelloMare*normalFactor),0f);
             GL11.glVertex3f(0f,(livelloMare*normalFactor),0f);

             GL11.glNormal3f( 0.0f, 0.0f, 1.0f);
             GL11.glVertex3f(0f,0f,(float)(latoMondo));
            GL11.glVertex3f((float)(latoMondo),0f,(float)(latoMondo));
            GL11.glVertex3f((float)(latoMondo),(livelloMare*normalFactor),(float)(latoMondo));
             GL11.glVertex3f(0f,(livelloMare*normalFactor),(float)(latoMondo));

      GL11.glEnd();                               // Done Drawing Sea
     }


      GL11.glBegin(GL11.GL_QUADS);                            // Start Drawing Terrain

      for (int ax=0;ax<map-1;ax++) {
         for (int az=0;az<map-1;az++) {
            choose(altezze[ax][az]);
            GL11.glVertex3f(ax,altezze[ax][az],az);
            choose(altezze[ax+1][az]);
            GL11.glVertex3f(ax+1,altezze[ax+1][az],az);
            choose(altezze[ax+1][az+1]);
            GL11.glVertex3f(ax+1,altezze[ax+1][az+1],az+1);
            choose(altezze[ax][az+1]);
            GL11.glVertex3f(ax,altezze[ax][az+1],az+1);
            }
      }
      GL11.glEnd();                               // Done Drawing terrain



      xrot+=xspeed;                               // Add xspeed To xrot
      yrot+=yspeed;                               // Add yspeed To yrot
      return true;
  }

[napier]

I haven't looked closely at your code (have to run out in a minute), so this is a quick thought:  how many bits are you using for depth testing?

I create Display like so:

int depthBufferBits = 24;
Display.create(new PixelFormat(0, depthBufferBits, 0));  // set bits per buffer: alpha, depth, stencil

When I used 8 bits for depth buffer, or left this at the default value (I think it's 8 ).  my depth testing got odd results, mostly visible when two objects intersected in a large scene.

[andretti]

I tried your solution changing Dysplay.create() with the code you wrote. But i got an exception like this "Could not apply pixel format to window". I post the code of a really silly change made to NeHe's Lesson07 that show you very well the effect i want to remove! This code makes two quads (almost perpendicular) intersect themselves. Try rotating a little and then stop rotation with S key when you can see well the two quads (You starts perpendicular to one of them). Then, looking at the two quads intersecting themselves (there's a sort of movement!) go far from them using "Page Up Key" (next or prior key, i don't know how you call them!). Look at the intersection...when you reach a particular distance you won't see them intersect anymore!! This is a very ugly effect!! How can i fix? Remeber to put a file called map.bmp (or change the code appropriately!) in a dir called Data. Thank you very much!

/*
*      This Code Was Created By Jeff Molofee 2000
*      A HUGE Thanks To Fredric Echols For Cleaning Up
*      And Optimizing The Base Code, Making It More Flexible!
*      If You've Found This Code Useful, Please Let Me Know.
*      Visit My Site At nehe.gamedev.net
*/

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.nio.FloatBuffer;

import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.glu.GLU;
import org.lwjgl.devil.IL;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.PixelFormat;

/**
* @author Mark Bernard
* date:    16-Nov-2003
*
* Port of NeHe's Lesson 7 to LWJGL
* Title: Texture Filters, Lighting & Keyboard Control
* Uses version 0.94alpha of LWJGL http://www.lwjgl.org/
*
* Be sure that the LWJGL libraries are in your classpath
*
* Ported directly from the C++ version
*
* 2004-05-08: Updated to version 0.9alpha of LWJGL.
*             Changed from all static to all instance objects.
* 2004-09-22: Updated to version 0.92alpha of LWJGL.
* 2004-12-19: Updated to version 0.94alpha of LWJGL and to use
*             DevIL for image loading.
*/
public class Miniter2 {
  private boolean done = false;
  private boolean fullscreen = false;
  private final String windowTitle = "NeHe's OpenGL Lesson 7 for LWJGL (Texture Filters, Lighting & Keyboard Control)";
  private boolean f1 = false;
  private DisplayMode displayMode;

  private boolean light;                                      // Lighting ON / OFF
  private boolean lp;                                         // L Pressed?
  private boolean fp;                                         // F Pressed?
  private float xrot;                                         // X Rotation
  private float yrot;                                         // Y Rotation
  private float xspeed;                                       // X Rotation Speed
  private float yspeed;                                       // Y Rotation Speed
  private float z = -5.0f;                                        // Depth Into The Screen
  private float lightAmbient[] = { 0.5f, 0.5f, 0.5f, 1.0f };  // Ambient Light Values ( NEW )
  private float lightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };      // Diffuse Light Values ( NEW )
  private float lightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f }; // Light Position ( NEW )
  private int filter;                                         // Which Filter To Use
  private int texture[] = new int[3];                         // Storage for 3 textures
  private boolean keys[] = new boolean[9];
  public float startx=20f;

  public static void main(String args[]) {
      boolean fullscreen = false;
      if(args.length>0) {
          if(args[0].equalsIgnoreCase("fullscreen")) {
              fullscreen = true;
          }
      }

      Miniter2 l7 = new Miniter2();
      l7.run(fullscreen);
  }
  public void run(boolean fullscreen) {
      this.fullscreen = fullscreen;
      try {
          init();
          while (!done) {
              mainloop();
              render();
              Display.update();
          }
          cleanup();
      }
      catch (Exception e) {
          e.printStackTrace();
          System.exit(0);
      }
  }
  private void mainloop() {
      if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {       // Exit if Escape is pressed
          done = true;
      }
      if(Display.isCloseRequested()) {                     // Exit if window is closed
          done = true;
      }
      if(Keyboard.isKeyDown(Keyboard.KEY_F1) && !f1) {    // Is F1 Being Pressed?
          f1 = true;                                      // Tell Program F1 Is Being Held
          switchMode();                                   // Toggle Fullscreen / Windowed Mode
      }
      if(!Keyboard.isKeyDown(Keyboard.KEY_F1)) {          // Is F1 Being Pressed?
          f1 = false;
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_L) && !lp) {
          lp=true;
          light=!light;
          if (!light)                             // If Not Light
          {
              GL11.glDisable(GL11.GL_LIGHTING);       // Disable Lighting
          }
          else                                    // Otherwise
          {
              GL11.glEnable(GL11.GL_LIGHTING);        // Enable Lighting
          }
      }
      else if (!Keyboard.isKeyDown(Keyboard.KEY_L)) {
          lp=false;
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_F) && !fp) {    // Is F Key Being Pressed?
          fp=true;                                // fp Becomes TRUE
          filter+=1;                              // filter Value Increases By One
          if (filter>2            )               // Is Value Greater Than 2?
          {
              filter=0;                           // If So, Set filter To 0
          }
      }
      else if (!Keyboard.isKeyDown(Keyboard.KEY_F)) {     // Has F Key Been Released?
          fp=false;                               // If So, fp Becomes FALSE
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_PRIOR)) {       // Is Page Up Being Pressed?
          z-=1f;                               // If So, Move Into The Screen
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_NEXT)) {        // Is Page Down Being Pressed?
          z+=1f;                               // If So, Move Towards The Viewer
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {          // Is Up Arrow Being Pressed?
          xspeed-=0.01f;                          // If So, Decrease xspeed
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {        // Is Down Arrow Being Pressed?
          xspeed+=0.01f;                          // If So, Increase xspeed
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {       // Is Right Arrow Being Pressed?
          yspeed+=0.01f;                          // If So, Increase yspeed
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {        // Is Left Arrow Being Pressed?
          yspeed-=0.01f;                          // If So, Decrease yspeed
      }
      if (Keyboard.isKeyDown(Keyboard.KEY_S)) {        // Is Left Arrow Being Pressed?
          yspeed=0.0f;                          // If So, Decrease yspeed
          xspeed=0.0f;                          // If So, Decrease yspeed
      }
  }
  private void switchMode() {
      fullscreen = !fullscreen;
      try {
          Display.setFullscreen(fullscreen);
      }
      catch(Exception e) {
          e.printStackTrace();
      }
  }

  private boolean render() {
      GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);          // Clear The Screen And The Depth Buffer

      GL11.glLoadIdentity();                          // Reset The Current Modelview Matrix

      GL11.glTranslatef(0.0f,0.0f,z);                     // Translate Into/Out Of The Screen By z

      GL11.glRotatef(xrot,1.0f,0.0f,0.0f);                        // Rotate On The X Axis By xrot
      GL11.glRotatef(yrot,0.0f,1.0f,0.0f);                        // Rotate On The Y Axis By yrot
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture[filter]);                // Select A Texture Based On filter

      startx=startx-0.5f;
      if (startx<-20f)
         startx=20f;

      GL11.glBegin(GL11.GL_QUADS);                            // Start Drawing Quads
                   GL11.glColor3f(0.313f,0.313f,0.902f);
                   //Disegno livello del mare

                 GL11.glNormal3f(0.0f,-1.0f,0.0f);
                 GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f(startx,0f,-5.0f);
                 GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f(startx+10f,0f,-5.0f);
                 GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f(startx+10f,0f,5f);
                 GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f(startx,0f,5f);

                 GL11.glColor3f(1f,0f,0f);
                 GL11.glNormal3f(0.0f,0.0f,-1.0f);
                 GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f(-5.0f,5f,2f);
                 GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f(5f,5f,2f);
                 GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f(5f,-5f,0f);
                 GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f(-5f,-5f,0f);


      GL11.glEnd();


      /*
      GL11.glBegin(GL11.GL_QUADS);                            // Start Drawing Quads
      // Front Face
      GL11.glNormal3f( 0.0f, 0.0f, 1.0f);                 // Normal Pointing Towards Viewer
      GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f(-1.0f, -1.0f,  1.0f);    // Point 1 (Front)
      GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f( 1.0f, -1.0f,  1.0f);    // Point 2 (Front)
      GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f( 1.0f,  1.0f,  1.0f);    // Point 3 (Front)
      GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f(-1.0f,  1.0f,  1.0f);    // Point 4 (Front)
      // Back Face
      GL11.glNormal3f( 0.0f, 0.0f,-1.0f);                 // Normal Pointing Away From Viewer
      GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f(-1.0f, -1.0f, -1.0f);    // Point 1 (Back)
      GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f(-1.0f,  1.0f, -1.0f);    // Point 2 (Back)
      GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f( 1.0f,  1.0f, -1.0f);    // Point 3 (Back)
      GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f( 1.0f, -1.0f, -1.0f);    // Point 4 (Back)
      // Top Face
      GL11.glNormal3f( 0.0f, 1.0f, 0.0f);                 // Normal Pointing Up
      GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f(-1.0f,  1.0f, -1.0f);    // Point 1 (Top)
      GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f(-1.0f,  1.0f,  1.0f);    // Point 2 (Top)
      GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f( 1.0f,  1.0f,  1.0f);    // Point 3 (Top)
      GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f( 1.0f,  1.0f, -1.0f);    // Point 4 (Top)
      // Bottom Face
      GL11.glNormal3f( 0.0f,-1.0f, 0.0f);                 // Normal Pointing Down
      GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f(-1.0f, -1.0f, -1.0f);    // Point 1 (Bottom)
      GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f( 1.0f, -1.0f, -1.0f);    // Point 2 (Bottom)
      GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f( 1.0f, -1.0f,  1.0f);    // Point 3 (Bottom)
      GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f(-1.0f, -1.0f,  1.0f);    // Point 4 (Bottom)
      // Right face
      GL11.glNormal3f( 1.0f, 0.0f, 0.0f);                 // Normal Pointing Right
      GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f( 1.0f, -1.0f, -1.0f);    // Point 1 (Right)
      GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f( 1.0f,  1.0f, -1.0f);    // Point 2 (Right)
      GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f( 1.0f,  1.0f,  1.0f);    // Point 3 (Right)
      GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f( 1.0f, -1.0f,  1.0f);    // Point 4 (Right)
      // Left Face
      GL11.glNormal3f(-1.0f, 0.0f, 0.0f);                 // Normal Pointing Left
      GL11.glTexCoord2f(0.0f, 0.0f); GL11.glVertex3f(-1.0f, -1.0f, -1.0f);    // Point 1 (Left)
      GL11.glTexCoord2f(1.0f, 0.0f); GL11.glVertex3f(-1.0f, -1.0f,  1.0f);    // Point 2 (Left)
      GL11.glTexCoord2f(1.0f, 1.0f); GL11.glVertex3f(-1.0f,  1.0f,  1.0f);    // Point 3 (Left)
      GL11.glTexCoord2f(0.0f, 1.0f); GL11.glVertex3f(-1.0f,  1.0f, -1.0f);    // Point 4 (Left)
      GL11.glEnd();                               // Done Drawing Quads
      */

      xrot+=xspeed;                               // Add xspeed To xrot
      yrot+=yspeed;                               // Add yspeed To yrot
      return true;
  }
  private void createWindow() throws Exception {
      Display.setFullscreen(fullscreen);
      DisplayMode d[] = Display.getAvailableDisplayModes();
      for (int i = 0; i < d.length; i++) {
          if (d.getWidth() == 640
              && d.getHeight() == 480
              && d.getBitsPerPixel() == 32) {
              displayMode = d;
              break;
          }
      }
      Display.setDisplayMode(displayMode);
      Display.setTitle(windowTitle);
      Display.create();
  }
  private void init() throws Exception {
      createWindow();
      IL.create();

      loadTextures();
      initGL();
  }
  private void loadTextures() {
      texture = loadTexture("Data/map.bmp");
  }
  private void initGL() {
      GL11.glEnable(GL11.GL_TEXTURE_2D); // Enable Texture Mapping
      GL11.glShadeModel(GL11.GL_SMOOTH); // Enable Smooth Shading
      GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
      GL11.glClearDepth(1.0f); // Depth Buffer Setup
      GL11.glEnable(GL11.GL_DEPTH_TEST); // Enables Depth Testing
      GL11.glDepthFunc(GL11.GL_LEQUAL); // The Type Of Depth Testing To Do

      GL11.glMatrixMode(GL11.GL_PROJECTION); // Select The Projection Matrix
      GL11.glLoadIdentity(); // Reset The Projection Matrix

      // Calculate The Aspect Ratio Of The Window
      GLU.gluPerspective(45.0f, (float) displayMode.getWidth() / (float) displayMode.getWidth(),0.1f,800.0f);
      GL11.glMatrixMode(GL11.GL_MODELVIEW); // Select The Modelview Matrix

      // Really Nice Perspective Calculations
      GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
      //GL11.glPolygonMode(GL11.GL_FRONT, GL11.GL_FILL);
      //GL11.glPolygonMode(GL11.GL_BACK, GL11.GL_LINE);
      ByteBuffer temp = ByteBuffer.allocateDirect(16);
      temp.order(ByteOrder.nativeOrder());
      GL11.glLight(GL11.GL_LIGHT1, GL11.GL_AMBIENT, (FloatBuffer)temp.asFloatBuffer().put(lightAmbient).flip());              // Setup The Ambient Light
      GL11.glLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, (FloatBuffer)temp.asFloatBuffer().put(lightDiffuse).flip());              // Setup The Diffuse Light
      GL11.glLight(GL11.GL_LIGHT1, GL11.GL_POSITION,(FloatBuffer)temp.asFloatBuffer().put(lightPosition).flip());         // Position The Light
      GL11.glEnable(GL11.GL_LIGHT1);                          // Enable Light One
  }
  private void cleanup() {
      Display.destroy();
  }
  /**
   * Texture loading directly from LWJGL examples
   */
  private int[] loadTexture(String path) {
      IntBuffer image = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();
      IL.ilGenImages(1, image);
      IL.ilBindImage(image.get(0));
      IL.ilLoadImage(path);
      IL.ilConvertImage(IL.IL_RGB, IL.IL_BYTE);
      ByteBuffer scratch = ByteBuffer.allocateDirect(IL.ilGetInteger(IL.IL_IMAGE_WIDTH) * IL.ilGetInteger(IL.IL_IMAGE_HEIGHT) * 3);
      IL.ilCopyPixels(0, 0, 0, IL.ilGetInteger(IL.IL_IMAGE_WIDTH), IL.ilGetInteger(IL.IL_IMAGE_HEIGHT), 1, IL.IL_RGB, IL.IL_BYTE, scratch);

      // Create A IntBuffer For Image Address In Memory
      IntBuffer buf = ByteBuffer.allocateDirect(12).order(ByteOrder.nativeOrder()).asIntBuffer();
      GL11.glGenTextures(buf); // Create Texture In OpenGL

      GL11.glBindTexture(GL11.GL_TEXTURE_2D, buf.get(0));
      // Typical Texture Generation Using Data From The Image

      // Create Nearest Filtered Texture
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, buf.get(0));
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
      GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, IL.ilGetInteger(IL.IL_IMAGE_WIDTH),
              IL.ilGetInteger(IL.IL_IMAGE_HEIGHT), 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, scratch);

      // Create Linear Filtered Texture
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, buf.get(1));
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
      GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, IL.ilGetInteger(IL.IL_IMAGE_WIDTH),
              IL.ilGetInteger(IL.IL_IMAGE_HEIGHT), 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, scratch);

      // Create MipMapped Texture
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, buf.get(2));
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
      GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR_MIPMAP_NEAREST);
      GLU.gluBuild2DMipmaps(GL11.GL_TEXTURE_2D, 3, IL.ilGetInteger(IL.IL_IMAGE_WIDTH),
              IL.ilGetInteger(IL.IL_IMAGE_HEIGHT), GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, scratch);

    return new int[]{ buf.get(0), buf.get(1), buf.get(2) };     // Return Image Addresses In Memory
  }
}

[napier]

This sounds very familiar to the problem I was having, and the fix for me was to increase the number of bits per pixel in the depth buffer (from 8 to 24).  

24 bits provides a finer range of Z values, which improves the resolution of the depth test, especially valuable when zooming out of a scene as you describe.

The error you got suggests that your grafix card or video drivers do not support higher resolution in the depth buffer.  Take a look at this thread for another case of the "Could not apply pixel format to window" error:

http://lwjgl.org/forum/viewtopic.php?t=999

[tomb]

The fix is to push forward the near clipping plane as much as possible. It is the 3rd parameter in the following function:

GLU.gluPerspective(45.0f, (float) displayMode.getWidth() / (float) displayMode.getWidth(),0.1f,800.0f);

Instead of 0.1f try as high value as possible while still seeing the objects. Begin with 10.0f. That would give you enough precission. This can be a problem with landscape engines where you need to render large areas and also detailed object up close. There are other workarounds if you can't get a 24 bit depth buffer and you need the close clipping plane. You would have to render the scene several time each with a different set a near/far plane. Draw it twice with 0.1f, 10.0f and 10.0f,800.0f, etc.

[andretti]

That was the problem! Pushing away the view plane has solved the problem...at the high cost of losing control when i'm too near to the objects! It'll be a great trouble to code a changing view plane! I think that the problem about the depth buffer is due to my graphic card...an old matroxG200!! Maybe they don't even know what was a depth buffer at that time and xp drivers were updated too much time ago! Thank you all!