Welcome to the Java Programming Forums


The professional, friendly Java community. 21,500 members and growing!


The Java Programming Forums are a community of Java programmers from all around the World. Our members have a wide range of skills and they all have one thing in common: A passion to learn and code Java. We invite beginner Java programmers right through to Java professionals to post here and share your knowledge. Become a part of the community, help others, expand your knowledge of Java and enjoy talking with like minded people. Registration is quick and best of all free. We look forward to meeting you.


>> REGISTER NOW TO START POSTING


Members have full access to the forums. Advertisements are removed for registered users.

Results 1 to 2 of 2

Thread: First Person Camera

  1. #1
    Junior Member
    Join Date
    Nov 2010
    Posts
    2
    Thanks
    0
    Thanked 0 Times in 0 Posts

    Default First Person Camera

    I saw a code for a FPCamera on lloydgoodall.com. It had many, many errors, which I fixed.

    It loads, but for some reason, the mouse and keyboard don't do any effect on the program.

    My code:
    import org.lwjgl.Sys;
    import org.lwjgl.opengl.Display;
    import org.lwjgl.opengl.GL11;
    import org.lwjgl.util.vector.Vector3f;
    import org.lwjgl.input.Keyboard;
    import org.lwjgl.input.Mouse;
    import org.lwjgl.LWJGLException;
    import org.lwjgl.opengl.DisplayMode;
    import org.lwjgl.util.glu.GLU;
     
    //First Person Camera Controller
    public class FPCameraController
    {
        //3d vector to store the camera's position in
        private Vector3f    position    = null;
        //the rotation around the Y axis of the camera
        private float       yaw         = 0.0f;
        //the rotation around the X axis of the camera
        private float       pitch       = 0.0f;
        //Constructor that takes the starting x, y, z location of the camera
        public FPCameraController(float x, float y, float z)
        {
            //instantiate position Vector3f to the x y z params.
            position = new Vector3f(x, y, z);
        }
        public FPCameraController() {
    		// TODO Auto-generated constructor stub
    	}
    	//increment the camera's current yaw rotation
        public void yaw(float amount)
        {
            //increment the yaw by the amount param
            yaw += amount;
        }
     
        //increment the camera's current yaw rotation
        public void pitch(float amount)
        {
            //increment the pitch by the amount param
            pitch += amount;
        }
        //moves the camera forward relitive to its current rotation (yaw)
        public void walkForward(float distance)
        {
            position.x -= distance * (float)Math.sin(Math.toRadians(yaw));
            position.z += distance * (float)Math.cos(Math.toRadians(yaw));
        }
     
        //moves the camera backward relitive to its current rotation (yaw)
        public void walkBackwards(float distance)
        {
            position.x += distance * (float)Math.sin(Math.toRadians(yaw));
            position.z -= distance * (float)Math.cos(Math.toRadians(yaw));
        }
     
        //strafes the camera left relitive to its current rotation (yaw)
        public void strafeLeft(float distance)
        {
            position.x -= distance * (float)Math.sin(Math.toRadians(yaw-90));
            position.z += distance * (float)Math.cos(Math.toRadians(yaw-90));
        }
     
        //strafes the camera right relitive to its current rotation (yaw)
        public void strafeRight(float distance)
        {
            position.x -= distance * (float)Math.sin(Math.toRadians(yaw+90));
            position.z += distance * (float)Math.cos(Math.toRadians(yaw+90));
        }
     
        //translates and rotate the matrix so that it looks through the camera
        //this dose basic what gluLookAt() does
        public void lookThrough()
        {
            //roatate the pitch around the X axis
            GL11.glRotatef(pitch, 1.0f, 0.0f, 0.0f);
            //roatate the yaw around the Y axis
            GL11.glRotatef(yaw, 0.0f, 1.0f, 0.0f);
            //translate to the position vector's location
            GL11.glTranslatef(position.x, position.y, position.z);
        }
        private static boolean gameRunning=true;
        private static int targetWidth = 800;
        private static int targetHeight = 600;
     
        private float xrot=0.1f;
        private float yrot=0.1f;
        private float zrot=0.1f;
     
        /** The texture that’s been loaded */
     
        private static void initDisplay(boolean fullscreen){
     
            DisplayMode chosenMode = null;
     
            try {
                    DisplayMode[] modes = Display.getAvailableDisplayModes();
     
                    for (int i=0;i<modes.length;i++) {
                        if ((modes[i].getWidth() == targetWidth) && (modes[i].getHeight() == targetHeight)) {
                            chosenMode = modes[i];
                            break;
                        }
                    }
                } catch (LWJGLException e) {
            Sys.alert("Error", "Unable to determine display modes.");
            System.exit(0);
        }
     
            // at this point if we have no mode there was no appropriate, let the user know
        // and give up
            if (chosenMode == null) {
                Sys.alert("Error", "Unable to find appropriate display mode.");
                System.exit(0);
            }
     
            try {
                Display.setDisplayMode(chosenMode);
                Display.setFullscreen(fullscreen);
                Display.setTitle("ZOMBIES!");
                Display.create();
                Keyboard.create();
                Mouse.create();
            }
            catch (LWJGLException e) {
                Sys.alert("Error","Unable to create display.");
                System.exit(0);
            }
     
    }
     
        private static boolean initGL(){
            GL11.glMatrixMode(GL11.GL_PROJECTION);
            GL11.glLoadIdentity();
     
    //        Calculate the aspect ratio of the window
            GLU.gluPerspective(45.0f,((float)targetWidth)/((float)targetHeight),0.1f,100.0f);
            GL11.glMatrixMode(GL11.GL_MODELVIEW);
            GL11.glLoadIdentity();
     
            GL11.glEnable(GL11.GL_TEXTURE_2D);                                    // Enable Texture Mapping ( NEW )
            GL11.glShadeModel(GL11.GL_SMOOTH);
            GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            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);
            return true;
        }
     
        private void run(){
            while(gameRunning){
                update();
                render();
                Display.update();
     
                // finally check if the user has requested that the display be
                // shutdown
                if (Display.isCloseRequested()) {
                        gameRunning = false;
                        Display.destroy();
                        System.exit(0);
                    }
                }
        }
     
        private void update(){
            xrot+=0.1f;
            yrot+=0.1f;
            zrot+=0.1f;
        }
     
        private void render(){
            GL11.glClear(GL11.GL_COLOR_BUFFER_BIT|GL11.GL_DEPTH_BUFFER_BIT);
            GL11.glLoadIdentity();
     
            GL11.glTranslatef(0.0f,0.0f,-5.0f);                              // Move Into The Screen 5 Units
     
            GL11.glBegin(GL11.GL_QUADS);
     
                    // Front Face
                    GL11.glTexCoord2f(0.0f, 0.0f);
                    GL11.glVertex3f(-1.0f, -1.0f,  1.0f);   // Bottom Left Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 0.0f);
                    GL11.glVertex3f( 1.0f, -1.0f,  1.0f);   // Bottom Right Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 1.0f);
                    GL11.glVertex3f( 1.0f,  1.0f,  1.0f);   // Top Right Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 1.0f);
                    GL11.glVertex3f(-1.0f,  1.0f,  1.0f);   // Top Left Of The Texture and Quad
     
                    // Back Face
                    GL11.glTexCoord2f(1.0f, 0.0f);
                    GL11.glVertex3f(-1.0f, -1.0f, -1.0f);   // Bottom Right Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 1.0f);
                    GL11.glVertex3f(-1.0f,  1.0f, -1.0f);   // Top Right Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 1.0f);
                    GL11.glVertex3f( 1.0f,  1.0f, -1.0f);   // Top Left Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 0.0f);
                    GL11.glVertex3f( 1.0f, -1.0f, -1.0f);   // Bottom Left Of The Texture and Quad
     
                    // Top Face
                    GL11.glTexCoord2f(0.0f, 1.0f);
                    GL11.glVertex3f(-1.0f,  1.0f, -1.0f);   // Top Left Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 0.0f);
                    GL11.glVertex3f(-1.0f,  1.0f,  1.0f);   // Bottom Left Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 0.0f);
                    GL11.glVertex3f( 1.0f,  1.0f,  1.0f);   // Bottom Right Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 1.0f);
                    GL11.glVertex3f( 1.0f,  1.0f, -1.0f);   // Top Right Of The Texture and Quad
     
                    // Bottom Face
                    GL11.glTexCoord2f(1.0f, 1.0f);
                    GL11.glVertex3f(-1.0f, -1.0f, -1.0f);   // Top Right Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 1.0f);
                    GL11.glVertex3f( 1.0f, -1.0f, -1.0f);   // Top Left Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 0.0f);
                    GL11.glVertex3f( 1.0f, -1.0f,  1.0f);   // Bottom Left Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 0.0f);
                    GL11.glVertex3f(-1.0f, -1.0f,  1.0f);   // Bottom Right Of The Texture and Quad
     
                    // Right face
                    GL11.glTexCoord2f(1.0f, 0.0f);
                    GL11.glVertex3f( 1.0f, -1.0f, -1.0f);   // Bottom Right Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 1.0f);
                    GL11.glVertex3f( 1.0f,  1.0f, -1.0f);   // Top Right Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 1.0f);
                    GL11.glVertex3f( 1.0f,  1.0f,  1.0f);   // Top Left Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 0.0f);
                    GL11.glVertex3f( 1.0f, -1.0f,  1.0f);   // Bottom Left Of The Texture and Quad
     
                    // Left Face
                    GL11.glTexCoord2f(0.0f, 0.0f);
                    GL11.glVertex3f(-1.0f, -1.0f, -1.0f);   // Bottom Left Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 0.0f);
                    GL11.glVertex3f(-1.0f, -1.0f,  1.0f);   // Bottom Right Of The Texture and Quad
                    GL11.glTexCoord2f(1.0f, 1.0f);
                    GL11.glVertex3f(-1.0f,  1.0f,  1.0f);   // Top Right Of The Texture and Quad
                    GL11.glTexCoord2f(0.0f, 1.0f);
                    GL11.glVertex3f(-1.0f,  1.0f, -1.0f);   // Top Left Of The Texture and Quad
            GL11.glEnd();
        }
     
        public static void main(String[] args)
    {       
        	FPCameraController app = new FPCameraController();
        	initDisplay(false);
    		initGL();
    		//app.init();
    		app.run();
        	FPCameraController camera = new FPCameraController(0, 0, 0);
     
     
     
        float dx        = 0.0f;
        float dy        = 0.0f;
        float dt        = 0.0f; //length of frame
        float lastTime  = 0.0f; // when the last frame was
        float time      = 0.0f;
     
        float mouseSensitivity = 0.05f;
        float movementSpeed = 10.0f; //move 10 units per second
     
        //hide the mouse
        Mouse.setGrabbed(true);
     
        // keep looping till the display window is closed the ESC key is down
        //while (!Display.isCloseRequested() &&
        //       !Keyboard.isKeyDown(Keyboard.KEY_ESCAPE))
        //{
            time = Sys.getTime();
            dt = (time - lastTime)/1000.0f;
            lastTime = time;
     
     
            //distance in mouse movement from the last getDX() call.
            dx = Mouse.getDX();
            //distance in mouse movement from the last getDY() call.
            dy = Mouse.getDY();
     
            //controll camera yaw from x movement fromt the mouse
            camera.yaw(dx * mouseSensitivity);
            //controll camera pitch from y movement fromt the mouse
            camera.pitch(dy * mouseSensitivity);
     
     
            //when passing in the distrance to move
            //we times the movementSpeed with dt this is a time scale
            //so if its a slow frame u move more then a fast frame
            //so on a slow computer you move just as fast as on a fast computer
            if (Keyboard.isKeyDown(Keyboard.KEY_W))//move forward
            {
                camera.walkForward(movementSpeed*dt);
            }
            if (Keyboard.isKeyDown(Keyboard.KEY_S))//move backwards
            {
                camera.walkBackwards(movementSpeed*dt);
            }
            if (Keyboard.isKeyDown(Keyboard.KEY_A))//strafe left
            {
                camera.strafeLeft(movementSpeed*dt);
            }
            if (Keyboard.isKeyDown(Keyboard.KEY_D))//strafe right
            {
                camera.strafeRight(movementSpeed*dt);
            }
     
            //set the modelview matrix back to the identity
            GL11.glLoadIdentity();
            //look through the camera before you draw anything
            camera.lookThrough();
            //you would draw your scene here.
     
            //draw the buffer to the screen
            Display.update();
        }
     
    	}
    //}
    Last edited by Aaron; November 13th, 2010 at 12:03 PM.


  2. #2
    Member Darryl.Burke's Avatar
    Join Date
    Mar 2010
    Location
    Madgaon, Goa, India
    Posts
    491
    Thanks
    8
    Thanked 47 Times in 45 Posts

    Default Re: First Person Camera

    That code uses a lot of third party classes which we know nothing about. It's better if you seek help wherever you got those packages.

    db

Similar Threads

  1. Is there any intelligent person in the Java programming? plz
    By alaseier in forum What's Wrong With My Code?
    Replies: 15
    Last Post: June 4th, 2010, 02:12 PM
  2. retrieve the video stream from an Axis camera
    By nesrine18 in forum What's Wrong With My Code?
    Replies: 0
    Last Post: April 3rd, 2010, 03:39 AM
  3. New person Just trying to read a file of ints
    By dubois.ford in forum File I/O & Other I/O Streams
    Replies: 1
    Last Post: March 7th, 2010, 10:47 PM
  4. Replies: 2
    Last Post: November 3rd, 2009, 05:28 AM

Tags for this Thread