My Framerate on my "game" is extremely bad so i need some assistance - lwjgl

Question

My game is extremely laggy in framerate. I'm not sure exactly what it is, but my camera jumps around stupidly. I was wondering if anyone could help me. They only render what's on screen and don't render the sides you cannot see.
This code is for my first class called GE which is my main class
import static org.lwjgl.opengl.GL11.*;
import java.text.Format.Field;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.lwjgl.LWJGLException;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.newdawn.slick.opengl.Texture;
public class GE {
public static void main(String[] args) {
initDisplay();
gameLoop();
cleanUp();
}
public static void gameLoop() {
Texture front = Block.loadTexture(Block.getFront());
Texture back = Block.loadTexture(Block.getBack());
Texture Tright = Block.loadTexture(Block.getTright());
Texture Tleft = Block.loadTexture(Block.getTleft());
Texture top = Block.loadTexture(Block.getTop());
Texture bottom = Block.loadTexture(Block.getBottom());
Camera cam = new Camera(70, (float) Display.getWidth()
/ (float) Display.getHeight(), 0.3f, 1000);
while (!Display.isCloseRequested()) {
boolean forward = Keyboard.isKeyDown(Keyboard.KEY_W)
|| Keyboard.isKeyDown(Keyboard.KEY_UP);
boolean backward = Keyboard.isKeyDown(Keyboard.KEY_S)
|| Keyboard.isKeyDown(Keyboard.KEY_DOWN);
boolean left = Keyboard.isKeyDown(Keyboard.KEY_A);
boolean right = Keyboard.isKeyDown(Keyboard.KEY_D);
boolean crouch = Keyboard.isKeyDown(Keyboard.KEY_LSHIFT);
boolean jump = Keyboard.isKeyDown(Keyboard.KEY_SPACE);
if (forward)
cam.moveZ(2f);
if (backward)
cam.moveZ(-2f);
if (left)
cam.moveX(0.2f);// cam.rotateY(-0.1f);
if (right)
cam.moveX(-0.2f);// cam.rotateY(0.1f);
if (crouch)
cam.moveY(0.2f);
if (jump)
cam.moveY2(-0.2f);
if (Keyboard.isKeyDown(Keyboard.KEY_LEFT))
cam.rotateY(-2f);
if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT))
cam.rotateY(2f);
if (Keyboard.isKeyDown(Keyboard.KEY_Q))
cam.rotateX(-0.2f);
if (Keyboard.isKeyDown(Keyboard.KEY_Z))
cam.rotateX(0.2f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
cam.useView();
for(int x = 0; x < 100; x++){
for(int z = 0; z <100 ;z++){
glPushMatrix();
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
front.bind();
glBegin(GL_QUADS);
{
// FrontFace
glTexCoord2f(1, 1);
glVertex3f(x-1, -2, z);
glTexCoord2f(0, 1);
glVertex3f(x, -2, z);
glTexCoord2f(0, 0);
glVertex3f(x, -1, z);
glTexCoord2f(1, 0);
glVertex3f(x-1, -1, z);
}
glEnd();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
back.bind();
glBegin(GL_QUADS);
{
// BackFace
glTexCoord2f(1, 1);
glVertex3f(x, -2, z-1);
glTexCoord2f(0, 1);
glVertex3f(x-1, -2, z-1);
glTexCoord2f(0, 0);
glVertex3f(x-1, -1, z-1);
glTexCoord2f(1, 0);
glVertex3f(x, -1, z-1);
}
glEnd();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
top.bind();
glBegin(GL_QUADS);
{
// Top Face
glTexCoord2f(0, 0);
glVertex3f(x-1, -1, z-1);
glTexCoord2f(0, 1);
glVertex3f(x, -1, z-1);
glTexCoord2f(1, 1);
glVertex3f(x, -1, z);
glTexCoord2f(1, 0);
glVertex3f(x-1, -1, z);
}
glEnd();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
Tright.bind();
glBegin(GL_QUADS);
{
// RightFace
glTexCoord2f(0, 0);
glVertex3f(x, -1, z-1);
glTexCoord2f(0, 1);
glVertex3f(x, -2, z-1);
glTexCoord2f(1, 1);
glVertex3f(x, -2, z);
glTexCoord2f(1, 0);
glVertex3f(x, -1, z);
}
glEnd();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
Tleft.bind();
glBegin(GL_QUADS);
{
// LeftFace
glTexCoord2f(0, 0);
glVertex3f(x-1, -1, z);
glTexCoord2f(0, 1);
glVertex3f(x-1, -2, z);
glTexCoord2f(1, 1);
glVertex3f(x-1, -2, z-1);
glTexCoord2f(1, 0);
glVertex3f(x-1, -1, z-1);
}
glEnd();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
bottom.bind();
glBegin(GL_QUADS);
{
// BottomFace
glTexCoord2f(0, 0);
glVertex3f(x-1, -2, z-1);
glTexCoord2f(0, 1);
glVertex3f(x, -2, z-1);
glTexCoord2f(1, 1);
glVertex3f(x, -2, z);
glTexCoord2f(1, 0);
glVertex3f(x-1, -2, z);
}
glEnd();
}
glPopMatrix();
}
}
Display.update();
}
}
public static void cleanUp() {
Display.destroy();
}
public static void initDisplay() {
try {
Display.setDisplayMode(new DisplayMode(800, 600));
Display.setInitialBackground(135, 206, 260 );
Display.setTitle("#NervousBreakdown - Alpha 0.01");
Display.setResizable(true);
Display.create();
} catch (LWJGLException ex) {
Logger.getLogger(GE.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
and this is my second class Camera
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
public class Camera {
private float x;
private float y;
private float z;
private float rx;
private float ry;
private float rz;
private float fov;
private float aspect;
private float near;
private float far;
public Camera(float fov, float aspect, float near, float far) {
x = 0;
y = 0;
z = 0;
rx = 0;
ry = 0;
rz = 0;
this.fov = fov;
this.aspect = aspect;
this.near = near;
this.far = far;
initProjection();
}
private void initProjection() {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fov, aspect, near, far);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
public void useView() {
glRotatef(rx, 1, 0, 0);
glRotatef(ry, 0, 1, 0);
glRotatef(rz, 0, 0, 1);
glTranslatef(x, y, z);
}
public float getX() {
return x;
}
public float getY() {
return y;
}
public float getZ() {
return z;
}
public void setX(float x) {
this.x = x;
}
public void setY(float y) {
this.y = y;
}
public void setZ(float z) {
this.z = z;
}
public float getRX() {
return rx;
}
public float getRY() {
return ry;
}
public float getRZ() {
return rz;
}
public void setRX(float rx) {
this.rx = rx;
}
public void setRY(float ry) {
this.ry = ry;
}
public void setRZ(float rz) {
this.rz = rz;
}
public void moveZ(float amt) {
z += amt * Math.sin(Math.toRadians(ry + 90));// *
// Math.sin(Math.toRadians(rx
// + 90));
x += amt * Math.cos(Math.toRadians(ry + 90));
// y += amt * Math.sin(Math.toRadians(rx));
}
public void moveX(float amt) {
z += amt * Math.sin(Math.toRadians(ry));
x += amt * Math.cos(Math.toRadians(ry));
}
public void moveY(float amt){
y= (float) (y + 0.002);
}
public void moveY2(float amt){
y= (float) (y - 0.002);
}
public void rotateY(float amt) {
ry += amt;
}
public void rotateX(float amt) {
rx += amt;
}
public void rotateZ(float amt) {
rz += amt;
}
And finally my last class block, which sets the textures for each of the sides in the main block:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.newdawn.slick.opengl.Texture;
import org.newdawn.slick.opengl.TextureLoader;
public class Block {
static String block = "Grass";
static String Front;
static String Back;
static String Top;
static String Tright;
static String Tleft;
static String Bottom;
public static Texture loadTexture(String key) {
try {
return TextureLoader.getTexture("png", new FileInputStream(
new File("res/textures/" + key + ".png")));
} catch (IOException ex) {
Logger.getLogger(GE.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
public static String getFront(){
if(block == "Grass"){
Front = "SideGrass";
}
if(block == "Wood"){
Front = "Wood";
}
return Front;
}
public static String getBack(){
if(block == "Grass"){
Back = "SideGrass";
}
if(block == "Wood"){
Back = "Wood";
}
return Back;
}
public static String getBottom(){
if(block == "Grass"){
Bottom = "Dirt";
}
if(block == "Wood"){
Bottom = "TopWood";
}
return Bottom;
}
public static String getTleft(){
if(block == "Grass"){
Tleft = "SideGrass";
}
if(block == "Wood"){
Tleft = "Wood";
}
return Tleft;
}
public static String getTright(){
if(block == "Grass"){
Tright = "SideGrass";
}
if(block == "Wood"){
Tright = "Wood";
}
return Tright;
}
public static String getTop(){
if(block == "Grass"){
Top = "Grass";
}
if(block == "Wood"){
Top = "TopWood";
}
return Top;
}
}

Answer 1

Well for a start you're using immediate mode. Use display lists or VBOs instead...
http://www.youtube.com/watch?v=-89BM2y3WIA&list=SP19F2453814E0E315&index=27
(this guy has a whole series of LWJGL tutorials BTW)
You're also using separate textures for each side of the block. Part of why Minecraft renders so fast and uses such little memory because every block shares the same texture. Rather than having a different texture, each block type should have different texture coordinates.
Although its a more advanced optimization, you might also want to think about culling. Simple frustum culling (i.e. don't draw what you can't see anyway) should make a significant improvement.

Answer 2

Try to remove as much as you can in while the method is rendering, for example load your textures into the the class method, e.g:
public GE() {
//load textures and stuff you don't need to continuously loop

Answer 3

I see you are using immediate mode. This way of coding is deprecated for a good reason. It is ok to use it because I don't think support will drop for it anytime soon, but it is a bad idea to start learnig it now. Take an OpengGl reference card and look up what is deprecated and what is not. Also I do encourage you to set your context to forward compatibility (org.lwjgl.opengl.ContextAttribs), and use the right tutorials. Remember the only reason to use OpenGl is performance so don't waste your time to learn an interface that is too slow. Drawing a single qual with glBegin/glEnd is as expensive as drawing a full mesh.
Here is one: http://www.arcsynthesis.org/gltut/

Answer 4

You should move :
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
where the textures are loaded, (called only once per texture).
Another thing which might help, don't compare Strings this way, use .equals() instead :
if(block == "Wood"){
Front = "Wood";
}
becomes
if(block.equals("Wood")){
Front = "Wood";
}
And in fact, you shouldn't use strings at all when performances matters. You may try an enum type instead.