LWJGL Camera doesnt work with 3d and 2d UI

[Max svendsen]

Hello everyone, my current issue is one that i've been running my face into for a few months- and i've since moved on to some other interesting projects, but this issue keeps comming back to me, in short; whenever i want to use a 3d perspective camera with a 2d UI - i cannot seem to move the camera itself, i can draw the 2d, and i can draw the 3d, i can even draw both- but the camera just will not move- even if the actual values do change. (I.E the position vertex of the camera)

Perhaps i've hit the wall so many times i've gotten blind to some simple solution, but even comming back after awhile doesnt seem to enlighten me, so if any of you are able to find the issue and flick me over the ear with an answer- please do, you would help me immensely.

Also just a note, you and i might do/understand and program things differently, so please dont argue with me about proper code etiquette and such, it wont get us anywhere =) Feel free to ask however if anything seems to bother you.

This is just a complete collection of the different classes for you to look at -
///////////////////////////////////////////////////////////////////

import java.io.File;
import java.util.ArrayList;
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;


//@author Nocturnal

public class Start{

    boolean running = true;
    float time, lastTime, delta;
    static int startTime, endTime, frameTime;
        static short FPS;
    
    int scrX = 1200,
    scrY = 700;
    DisplayMode dm = new DisplayMode(scrX,scrY);
    
    Core core = new Core();
    Render rend = new Render(core);
    Camera cam = new Camera(0,0,0,rend);
    Control ctrl = new Control(cam, rend);
    Start(){
    
        run();
    }
    public void run(){
        Mouse.setGrabbed(true);
        
        try{
            init();
            
            while(running){
                if(Display.isCloseRequested() || Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)){
                    running = false;
                }
                startCount();
                time = Sys.getTime();
                delta = (time - lastTime) / 1000f;
                lastTime = time;
                
                cam.render(dm.getWidth(), dm.getHeight());
                //rend.render3D(dm.getWidth(), dm.getHeight()); //moved to cam class
                //rend.render2D(dm.getWidth(), dm.getHeight()); //see notes there 
                ctrl.control(delta);
                
                Display.sync(120);
                Display.update();
                getFPS();
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }
        
        Display.destroy();
    System.exit(0);
    }
    public void startCount(){
        startTime = (int) System.currentTimeMillis();
    }
    public void getFPS(){
        endTime = (int) System.currentTimeMillis();
        
        frameTime = frameTime+(endTime-startTime);
        FPS++;
            //System.out.println("Frame; "+FPS);
        if(frameTime >= 1000){
            rend.currentFPS = FPS;
            
        frameTime = 0;
        FPS = 0;
        }
    }
    public void init(){
        createWindow();
        initGL();
        core.initFont();
        core.initFont2();
        core.loadTexture();
    }
        public void initGL(){
            
            GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            GL11.glClearDepth(1.0);
            GL11.glEnable(GL11.GL_DEPTH_TEST);
            GL11.glDepthFunc(GL11.GL_LEQUAL);

            GL11.glMatrixMode(GL11.GL_PROJECTION);
            GL11.glLoadIdentity();

            GLU.gluPerspective(45,
                dm.getWidth() / dm.getHeight(),
                0.01f, 1000f);
            GL11.glMatrixMode(GL11.GL_MODELVIEW);
            GL11.glLoadIdentity();
        }
    public void createWindow(){
        try{
            Display.setDisplayMode(dm);
            Display.setResizable(false);
            Display.setTitle("Cam/GUI Test - v0.1");
            Display.create();
        }catch(LWJGLException ex){
        }
    }
    
    public static void main(String[] args) {
        Start s = new Start();
    }
}

//////////////////////////////////////////////////////////////////


import java.util.UUID;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;


//@author Nocturnal

public class Control{
    boolean clickState = false;
    
    float sensitivity = 0.1f;
    float delta;
        float dx, dy;
    float speed = 5f;
    
    Camera cam;
    Render rend;
    UUID uuid;
    Control(Camera cam, Render r){
        uuid = UUID.randomUUID();
        System.out.println("Control-"+uuid);
        this.cam = cam;
        this.rend = r;
    }
    public void control(float  delta){
        this.delta = delta;
        
            dx = Mouse.getDX();
                cam.yaw(dx * sensitivity);
            dy = Mouse.getDY();
                cam.pitch(dy * sensitivity);
        
        if (Keyboard.isKeyDown(Keyboard.KEY_W)) {
                cam.forward(speed * delta);
                //rend.rotY+=0.1f; (IGNORE THESE - i used them to make sure i was rendering)
        }
        if (Keyboard.isKeyDown(Keyboard.KEY_S)) {
                cam.backward(speed * delta);
                //rend.rotY-=0.1f;
        }
        if (Keyboard.isKeyDown(Keyboard.KEY_A)) {
                cam.left(speed * delta);
                //rend.rotX+=0.1f;
        }
        if (Keyboard.isKeyDown(Keyboard.KEY_D)) {
                cam.right(speed * delta);
                //rend.rotX-=0.1f;
        }
        if (Keyboard.isKeyDown(Keyboard.KEY_SPACE)) {
                cam.up(speed * delta);
        }
        if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
                cam.down(speed * delta);
        }
            if(!clickState && Mouse.isButtonDown(0)){
                clickState = true;
            }
            if(clickState && !Mouse.isButtonDown(0)){
                clickState = false;
            }
    }
}

/////////////////////////////////////////////////////////////////////////////


import java.util.UUID;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.Sphere;
import org.lwjgl.util.vector.Vector3f;

class Camera{
    private Vector3f position = null;
    private float yaw = 0.0f;
    private float pitch = 0.0f;
    
    Render rend;
    UUID uuid;
    Camera(float x, float y, float z, Render r){
        uuid = UUID.randomUUID();
        System.out.println("Camera-"+uuid);
        position = new Vector3f(x,y,z);
        this.rend = r;
    }
    public void yaw(float amount){
        yaw += amount;
    }
    public void pitch(float amount){
        pitch -= amount;
    }
    public void forward(float distance){
        position.x -= distance * (float)Math.sin(Math.toRadians(yaw));
        position.z += distance * (float)Math.cos(Math.toRadians(yaw));
    }
    public void backward(float distance){
        position.x += distance * (float)Math.sin(Math.toRadians(yaw));
        position.z -= distance * (float)Math.cos(Math.toRadians(yaw));
    }
    public void left(float distance){
        position.x -= distance * (float)Math.sin(Math.toRadians(yaw-90));
        position.z += distance * (float)Math.cos(Math.toRadians(yaw-90));
    }
    public void right(float distance){
        position.x -= distance * (float)Math.sin(Math.toRadians(yaw+90));
        position.z += distance * (float)Math.cos(Math.toRadians(yaw+90));
    }
    public void up(float distance){
        position.y -= distance;
    }
    public void down(float distance){
        position.y += distance;
    }
        
    public void render(float w, float h){
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glLoadIdentity();
        
        GL11.glPushMatrix();
        GL11.glRotatef(pitch, 1.0f, 0.0f, 0.0f);
        GL11.glRotatef(yaw, 0.0f, 1.0f, 0.0f);
        GL11.glTranslatef(position.x, position.y, position.z);
        GL11.glPopMatrix();
        
        
        rend.render3D(w, h); //usually these is in the main loop- but i tried to put them 
        rend.render2D(w, h); //in this class to check some things
    }
}

////////////////////////////////////////////////////////////////////////

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.UUID;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.GLU;
import org.newdawn.slick.opengl.Texture;
import org.newdawn.slick.opengl.TextureLoader;

//@author Nocturnal

public class Render{
    String windowName= ""; //ignore these, was for a 2d project i made awhile ago
    String subWindow= ""; // <--
    boolean intro = true; // <--
    
    Core core;
    UUID uuid;
    Render(Core c){
        uuid = UUID.randomUUID();
        System.out.println("Render-"+uuid);
        this.core = c;
    }
    String tempText;
    boolean girlsJustWannaHaveFun/*=true*/; //ignore this, was having some fun with another project.
    int mX,mY;
    int currentFPS;
    float tempYaw;
    

    public void render3D(float w, float h){
        GL11.glLoadIdentity();
        GL11.glClearDepth(1.0);
        
        //GL11.glDisable(GL11.GL_TEXTURE_2D);
        //GL11.glDisable(GL11.GL_BLEND);
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glDepthFunc(GL11.GL_LEQUAL);

        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();

        GLU.gluPerspective(45,
                w / h,
                0.01f, 1000f);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        
        //Start Rendering 3D
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glLoadIdentity();
        
        
        worldBox();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, 1);
    }
    public void render2D(float w, float h){
        GL11.glLoadIdentity();
        GL11.glDisable(GL11.GL_TEXTURE_2D);
	GL11.glShadeModel(GL11.GL_SMOOTH); 
	GL11.glDisable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();
        GL11.glOrtho(0, w, h, 0, 1f, -1f);

        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        
        //Start Rendering 2D
        GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        GL11.glLoadIdentity();
        
        
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        
        tempText = "X; "+mX;			//some of this was used in a 2d project.
        core.writeSmall(tempText, 1000, 10);	//hence the XY.
        tempText = "Y; "+mY;
        core.writeSmall(tempText, 1000, 25);
        tempText = "FPS; "+currentFPS;
        core.writeSmall(tempText, 1100, 10);
        tempText = "Yaw; "+tempYaw;
        core.writeSmall(tempText, 1100, 25);
        
        core.write2D("----", 12, 25);
        core.write2D("----", 10, 10);
        GL11.glDisable(GL11.GL_TEXTURE_2D);
    }
    
        int x = 200, y = 200, z = 200;
        float rotX,rotY,rotZ;
    public void worldBox(){
        
	//removed irrelevant code here - was more or less just a textured box
	
    }
}

////////////////////////////////////////////////////////////

There is also a core class- but it has nothing to do with the issue so i wont post it. And also sorry for the abusive use of loadIdentity, tried to figure out some things and i havent gotten around to cleaning it up yet.

[Max svendsen]

Nobody have any idea of how to aid me in this? I've been actively trying to fix this and have yet to get any closer to my answer.

I will post it here if i find the answer on my own, incase anyone looking would like an answer for this aswell.