public void GET_INIT_GL3D() {
       GL11.glMatrixMode(GL11.GL_PROJECTION);
       GL11.glLoadIdentity();
       GLU.gluPerspective(65.0f, (float) (DISPLAY_WIDTH / DISPLAY_HEIGHT),
         0.0001f, 1050);
       GL11.glMatrixMode(GL11.GL_MODELVIEW);
       GL11.glLoadIdentity();
       GL11.glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
       GL11.glShadeModel(GL11.GL_SMOOTH);
       GL11.glClearDepth(1.0f);
       GL11.glEnable(GL11.GL_DEPTH_TEST);
       GL11.glDepthFunc(GL11.GL_LEQUAL);
       GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
       GL11.glEnable(GL11.GL_TEXTURE_2D);
      }

       GL11.glMatrixMode(GL11.GL_PROJECTION);
       GL11.glLoadIdentity();
       GLU.gluPerspective(65.0f, (float) (DISPLAY_WIDTH / DISPLAY_HEIGHT),
         0.0001f, 1050);
       GL11.glMatrixMode(GL11.GL_MODELVIEW);
       GL11.glLoadIdentity();

      public void GET_INIT_RENDER() {
       // Очистить экран и буфер глубины
       GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
       GL11.glLoadIdentity();
      }

      public static float dt = 0.0f;
      public static long lastFPS;
      public static long lastFrame;
      public static int fps;

//...

      public static long GetTime() {
       return (Sys.getTime() * 1000) / Sys.getTimerResolution();
      }

      public void UpdateFPS() {
       if (GetTime() - lastFPS > 1000) {
        Display.setTitle(TITLE + " FPS: " + fps);
        fps = 0;
        lastFPS += 1000;
       }
       fps++;
      }

//...

      public void GET_INIT_RENDER() {
       // Очистить экран и буфер глубины
       GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
       GL11.glLoadIdentity();
                     UpdateFPS();
      }

//...

      public void GET_INIT_RUNNING() {
       float lastTime = 0.0f;
       float time = 0.0f;
       lastFPS = GetTime();
       // цикл будет работать до тех пор, пока RUNNING не будет равен false;
       // окно не будет закрыто; пользователь не нажмет клавишу ESC.
       while (RUNNING && !Display.isCloseRequested()
         && !keys[Keyboard.KEY_ESCAPE]) {
        time = Sys.getTime();
        dt = (time - lastTime) / 1000.0f;
        lastTime = time;
        GET_INIT_UPDATE();
        // обновление окна
        Display.update();
       }
       // asCrash == false это число 0. Выход в нормальном состоянии
       cleanUp(false);
      }

import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

public class Camera {

      private boolean moveForward = false;
      private boolean moveBackward = false;
      private boolean strafeLeft = false;
      private boolean strafeRight = false;
           
      private boolean onGround = false, jumping = false, falling = false;
      private final float gravity = 0.0100f;

      public float movementSpeed = 8.0f;
      public float yBottom = 0;
      public float yMotion = 0;

      public Main world;

      static Vector3f vector = new Vector3f();
      Vector3f rotation = new Vector3f();
      Vector3f previous = new Vector3f();

      public Camera(Main app) {
       world = app;
      }

      public Camera() {

      }

      public static float getX() {
       return vector.x;
      }

      public static float getY() {
       return vector.y;
      }

      public static float getZ() {
       return vector.z;
      }

      public void Update() {
       UpdatePreviousVector();
       UpdateMotion(movementSpeed * Main.dt);
       Input();
       collisions(-0.9f);
       Physics();
      }

      // позиуия камеры
      public void TranslateCamera() {
       GL11.glRotatef(rotation.x, 1.0f, 0.0f, 0.0f);
       GL11.glRotatef(rotation.y, 0.0f, 1.0f, 0.0f);
       GL11.glRotatef(rotation.z, 0.0f, 0.0f, 1.0f);
       GL11.glTranslatef(-vector.x, -vector.y - 2.4f, -vector.z);
      }

      public void UpdatePreviousVector() {
       previous.x = vector.x;
       previous.y = vector.y;
       previous.z = vector.z;
      }
           
      // физика камеры
      public void Physics() {
       onGround = (vector.y == yBottom && !jumping && !falling);
       jumping = (yMotion > 0);
       falling = (yMotion < 0);
       vector.y += yMotion;
       if (vector.y > yBottom) {
        yMotion -= gravity;
       }
       if (vector.y <= yBottom) {
        vector.y = yBottom;
        yMotion = 0;
       }
      }

      public void collisions(float offset) {
       if (!ontopOfCollidablePoly(offset)) {
        yBottom = 0;
       }
       for (Quad v : world.quad) {
        if (Math.abs(vector.x - v.centerX) < v.width / 2
          && Math.abs(vector.z - v.centerZ) < v.length / 2) {
         if ((Math.abs(vector.y - v.yTop * 2) < v.height + (offset))
           || vector.y > v.yBottom + v.height - 0.5f) {
          yBottom = v.y1 + v.yTop;
         } else if (v.yBottom > vector.y + 2.4f) {

         } else {
          vector.x = previous.x;
          vector.z = previous.z;
         }
        }
       }
      }

      private boolean ontopOfCollidablePoly(float offset) {
       for (Quad v : world.quad) {
        if (Math.abs(vector.x - v.centerX) < v.width / 2
          && Math.abs(vector.z - v.centerZ) < v.length / 2) {
         return true;
        }
       }
       return false;
      }
           
      // управление
      public void Input() {
       if (Main.keys[Keyboard.KEY_W]) {
        moveForward = true;
       } else {
        moveForward = false;
       }
       if (Main.keys[Keyboard.KEY_S]) {
        moveBackward = true;
       } else {
        moveBackward = false;
       }
       if (Main.keys[Keyboard.KEY_A]) {
        strafeLeft = true;
       } else {
        strafeLeft = false;
       }
       if (Main.keys[Keyboard.KEY_D]) {
        strafeRight = true;
       } else {
        strafeRight = false;
       }
       if (Main.keys[Keyboard.KEY_SPACE] && onGround) {
        yMotion = 0.2f;
       }
       // если курсор исчез...
       if (Mouse.isGrabbed()) {
        // произойдет FIX камеры
        float mouseDX = Mouse.getDX() * 0.8f * 0.16f;
        float mouseDY = Mouse.getDY() * 0.8f * 0.16f;
        if (rotation.y + mouseDX >= 360) {
         rotation.y = rotation.y + mouseDX - 360;
        } else if (rotation.y + mouseDX < 0) {
         rotation.y = 360 - rotation.y + mouseDX;
        } else {
         rotation.y += mouseDX;
        }
        if (rotation.x - mouseDY >= -89 && rotation.x - mouseDY <= 89) {
         rotation.x += -mouseDY;
        } else if (rotation.x - mouseDY < -89) {
         rotation.x = -89;
        } else if (rotation.x - mouseDY > 89) {
         rotation.x = 89;
        }
       }
      }

      public void UpdateMotion(float distance) {
       if (moveForward) {
        vector.x += distance * (float) Math.sin(rotation.y * Math.PI / 180);
        vector.z += -distance
          * (float) Math.cos(rotation.y * Math.PI / 180);
       }
       if (moveBackward) {
        vector.x -= distance * (float) Math.sin(rotation.y * Math.PI / 180);
        vector.z -= -distance
          * (float) Math.cos(rotation.y * Math.PI / 180);
       }
       if (strafeLeft) {
        vector.x += distance
          * (float) Math.sin((rotation.y - 90) * Math.PI / 180);
        vector.z += -distance
          * (float) Math.cos((rotation.y - 90) * Math.PI / 180);
       }
       if (strafeRight) {
        vector.x += distance
          * (float) Math.sin((rotation.y + 90) * Math.PI / 180);
        vector.z += -distance
          * (float) Math.cos((rotation.y + 90) * Math.PI / 180);
       }
      }
}

import org.lwjgl.opengl.GL11;

public class Quad {

      float x1, y1, z1, x2, y2, z2, centerX, centerY, centerZ;
      float width, height, length;
      float yTop2;
      float yTop, yBottom;
      int num;
      float cX2, cY2, cZ2;

      public Quad(float startX, float startY, float startZ, float endX,
        float endY, float endZ, int number, float gh, float hj, float yu) {
       x1 = startX;
       y1 = startY;
       z1 = startZ;
       x2 = endX;
       y2 = endY;
       z2 = endZ;
       width = x2 - x1;
       height = y2 - y1;
       length = z2 - z1;
       centerX = x1 + (width / 2);
       centerY = y2 + (height / 2);
       centerZ = z1 + (length / 2);
       yTop = Math.abs(y2 - y1);
       yBottom = y1 + yTop - height;
       num = number;
       cX2 = gh;
       cY2 = hj;
       cZ2 = yu;
      }

      // рендер блока
      public void render() {
       GL11.glPushMatrix();
       GL11.glColor3f(cX2, cY2, cZ2);
       GL11.glBegin(GL11.GL_QUADS);
       // Top
       GL11.glVertex3f(x1, y1, z1);
       GL11.glTexCoord2f(0, 0);
       GL11.glVertex3f(x1 + width, y1, z1);
       GL11.glTexCoord2f(0.9f, 0);
       GL11.glVertex3f(x1 + width, y1, z1 + length);
       GL11.glTexCoord2f(0.9f, 0.9f);
       GL11.glVertex3f(x1, y1, z1 + length);
       GL11.glTexCoord2f(0, 0.9f);
       // Bottom
       GL11.glVertex3f(x1, y1 + height, z1);
       GL11.glTexCoord2f(0, 0);
       GL11.glVertex3f(x1 + width, y1 + height, z1);
       GL11.glTexCoord2f(0.9f, 0);
       GL11.glVertex3f(x1 + width, y1 + height, z1 + length);
       GL11.glTexCoord2f(0.9f, 0.9f);
       GL11.glVertex3f(x1, y1 + height, z1 + length);
       GL11.glTexCoord2f(0, 0.9f);
       // Front
       GL11.glVertex3f(x1, y1, z1);
       GL11.glTexCoord2f(0, 0);
       GL11.glVertex3f(x1 + width, y1, z1);
       GL11.glTexCoord2f(0.9f, 0);
       GL11.glVertex3f(x1 + width, y1 + height, z1);
       GL11.glTexCoord2f(0.9f, 0.9f);
       GL11.glVertex3f(x1, y1 + height, z1);
       GL11.glTexCoord2f(0, 0.9f);
       // Back
       GL11.glVertex3f(x1, y1, z1 + length);
       GL11.glTexCoord2f(0, 0);
       GL11.glVertex3f(x1 + width, y1, z1 + length);
       GL11.glTexCoord2f(0.9f, 0);
       GL11.glVertex3f(x1 + width, y1 + height, z1 + length);
       GL11.glTexCoord2f(0.9f, 0.9f);
       GL11.glVertex3f(x1, y1 + height, z1 + length);
       GL11.glTexCoord2f(0, 0.9f);
       // Left side
       GL11.glVertex3f(x1, y1, z1);
       GL11.glTexCoord2f(0, 0);
       GL11.glVertex3f(x1, y1, z1 + length);
       GL11.glTexCoord2f(0.9f, 0);
       GL11.glVertex3f(x1, y1 + height, z1 + length);
       GL11.glTexCoord2f(0.9f, 0.9f);
       GL11.glVertex3f(x1, y1 + height, z1);
       GL11.glTexCoord2f(0, 0.9f);
       // Right side
       GL11.glVertex3f(x1 + width, y1, z1);
       GL11.glTexCoord2f(0, 0);
       GL11.glVertex3f(x1 + width, y1, z1 + length);
       GL11.glTexCoord2f(0.9f, 0);
       GL11.glVertex3f(x1 + width, y1 + height, z1 + length);
       GL11.glTexCoord2f(0.9f, 0.9f);
       GL11.glVertex3f(x1 + width, y1 + height, z1);
       GL11.glTexCoord2f(0, 0.9f);
       GL11.glEnd();
       GL11.glPopMatrix();
      }
}

import java.util.ArrayList;
import java.util.List;

import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.GLU;

public class Main {

      public static boolean[] keys = new boolean[256];
      public static final int DISPLAY_WIDTH = 800;
      public static final int DISPLAY_HEIGHT = 600;
      public String TITLE = "GL3Dgame";
      public boolean VSYNC_ENABLED = false;
      public boolean RUNNING = true;
      public static final int MAX_FPS = 100;
      public static float dt = 0.0f;
      public static long lastFPS;
      public static long lastFrame;
      public static int fps;

      // создание камеры
      Camera camera = new Camera(this);

      // блоки
      List<Quad> quad = new ArrayList<Quad>();

      // конструктор главного класса Main.
      public Main() {
       // добавить один блок
       // quad.add(new Quad(startX, startY, startZ, endX, endY, endZ, textureNum, colorX, colorY, colorZ));
       // что значит textureNum, вы узнаете в следующем уроке.
       quad.add(new Quad(4, 0.1f, 4, 6, 2.1f, 6, 1, 1, 1, 1));
      }

      public static long GetTime() {
       return (Sys.getTime() * 1000) / Sys.getTimerResolution();
      }

      public void UpdateFPS() {
       if (GetTime() - lastFPS > 1000) {
        Display.setTitle(TITLE + " FPS: " + fps);
        fps = 0;
        lastFPS += 1000;
       }
       fps++;
      }

      // заготовка для настройки дисплея.
      public void GET_INIT_DISPLAY() {
       try {
        // настраиваем размеры окна, в моем случае это 800x600
        Display.setDisplayMode(new DisplayMode(DISPLAY_WIDTH,
          DISPLAY_HEIGHT));
        // меняем заголовок окна
        Display.setTitle(TITLE);
        // вертикальная синхронизация в этот момент отключена
        Display.setVSyncEnabled(VSYNC_ENABLED);
        // создаем окно
        Display.create();
        // если появилась ошибка...
       } catch (LWJGLException e) {
        // выводим в консоль сообщение об ошибке
        System.err.println("Error: Display.create");
        // здесь объяснять не буду.
        e.printStackTrace();
        // asCrash == true это число 1, сообщаем всем, что причина очистки
        // из за ошибки
        cleanUp(true);
       }

       // это настройка Opengl
       GET_INIT_GL3D();
       // запускаем цикл
       GET_INIT_RUNNING();
      }

      // заготовка для настройки 3D OpenGL.
      public void GET_INIT_GL3D() {
       GL11.glMatrixMode(GL11.GL_PROJECTION);
       GL11.glLoadIdentity();
       GLU.gluPerspective(65.0f, (float) (DISPLAY_WIDTH / DISPLAY_HEIGHT),
         0.0001f, 1050);
       GL11.glMatrixMode(GL11.GL_MODELVIEW);
       GL11.glLoadIdentity();
       GL11.glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
       GL11.glShadeModel(GL11.GL_SMOOTH);
       GL11.glClearDepth(1.0f);
       GL11.glEnable(GL11.GL_DEPTH_TEST);
       GL11.glDepthFunc(GL11.GL_LEQUAL);
       GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
       GL11.glEnable(GL11.GL_TEXTURE_2D);
      }

      public void GET_INIT_RENDER() {
       // Очистить экран и буфер глубины
       GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
       GL11.glLoadIdentity();
       // установка позиции камеры
       camera.TranslateCamera();
       // рендеринг всех блоков
       for (Quad q : quad) {
        q.render();
       }
      }

      // здесь мы поместим все в один метод, чтобы было легче работать.
      public void GET_INIT_UPDATE() {
       // установка камеры
       camera.Update();
       // скрытие курсора
       Mouse.setGrabbed(true);
       mapKeys();
       GET_INIT_RENDER();
       UpdateFPS();
      }

      // ну а здесь будет главный цикл игры.
      public void GET_INIT_RUNNING() {
       float lastTime = 0.0f;
       float time = 0.0f;
       lastFPS = GetTime();
       // цикл будет работать до тех пор, пока RUNNING не будет равен false;
       // окно не будет закрыто; пользователь не нажмет клавишу ESC.
       while (RUNNING && !Display.isCloseRequested()
         && !keys[Keyboard.KEY_ESCAPE]) {
        time = Sys.getTime();
        dt = (time - lastTime) / 1000.0f;
        lastTime = time;
        GET_INIT_UPDATE();
        // обновление окна
        Display.update();
        Display.sync(MAX_FPS);
       }
       // asCrash == false это число 0. Выход в нормальном состоянии
       cleanUp(false);
      }

      // массив для хранения Keyboard
      public void mapKeys() {
       for (int i = 0; i < keys.length; i++) {
        keys[i] = Keyboard.isKeyDown(i);
       }
      }

      // очистка и разрушение окна
      public void cleanUp(boolean asCrash) {
       Display.destroy();
       System.exit(asCrash ? 1 : 0);
      }

      // здесь и так все понятно.
      public static void main(String[] args) {
       Main main = new Main();
       main.GET_INIT_DISPLAY();
      }
}