OpenGL camera position does not match rendered image

Question

I'm playing around with creating a small voxel based project with LWJGL. Part of the project is loading small chunks of landscape around the player as they move. The loading part of this works okay, but I ran into an issue where as I walked along the +X axis, the chunks of landscape moving the same distance along the -X axis would load. This would also happen for the Z axis.

I got curious, so I tried reversing the X and Z axis rendering direction on the chunks, which seemed to fix the issue. However, I also decided to render the axis as lines as well, and verify that everything was now drawing correctly, with which I generated the following image:

(I can't embed images apparently, so link: https://i.sstatic.net/2hzAc.png)

In this image, the red, blue and green lines are drawn along the negative axes, whereas the purple, yellow and cyan lines are drawn along the positive axes. What's really weird about this is that the image is showing that the camera is in the +X and +Z range, but internally, the position vector of the camera is in the -X and -Z range. This would make sense as to why the chunks were loading on the opposite axis, as if the camera was rendering on +X but was internally at a position of -X, then the -X chunks would be loaded instead.

So I'm not sure what's going on here anymore. I'm sure there's a small setting or incorrect positive/negative that I'm missing, but I just can't seem to find anything. So I guess my question is, is the camera rendering correctly with the internal position? If so, do I need to just reverse everything that I render? If not, is there something clearly visible in the camera that is messing up the rendering?

Some snippets of relevant code, trying to not to overflow the post with code blocks

Camera.java

public class Camera {

    // Camera position
    private Vector3f position = new Vector3f(x, y, z);

    // Camera view properties
    private float pitch = 1f, yaw = 0.0f, roll = 0.0f;

    // Mouse sensitivity
    private float mouseSensitivity = 0.25f;

    // Used to change the yaw of the camera
    public void yaw(float amount) {
        this.yaw += (amount * this.mouseSensitivity);
    }

    // Used to change the pitch of the camera
    public void pitch(float amount) {
        this.pitch += (amount * this.mouseSensitivity);
    }

    // Used to change the roll of the camera
    public void roll(float amount) {
        this.roll += amount;
    }

    // Moves the camera forward relative 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 relative 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 relative 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 relative 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 rotates the matrix so that it looks through the camera
    public void lookThrough() {
        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);
    }
}

Main.java render code

private void render() {
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glLoadIdentity();

        // Set the view matrix to the player's view
        this.player.lookThrough();

        // Render the visible chunks
        this.chunkManager.render();

        // Draw axis
        GL11.glBegin(GL11.GL_LINES);

            // X Axis
            GL11.glColor3f(1, 0, 0);
            GL11.glVertex3f(-100, 0, 0);
            GL11.glVertex3f(0, 0, 0);

            GL11.glColor3f(1, 1, 0);
            GL11.glVertex3f(0, 0, 0);
            GL11.glVertex3f(100, 0, 0);

            // Y Axis
            GL11.glColor3f(0, 1, 0);
            GL11.glVertex3f(0, -100, 0);
            GL11.glVertex3f(0, 0, 0);

            GL11.glColor3f(0, 1, 1);
            GL11.glVertex3f(0, 0, 0);
            GL11.glVertex3f(0, 100, 0);

            // Z Axis
            GL11.glColor3f(0, 0, 1);
            GL11.glVertex3f(0, 0, -100);
            GL11.glVertex3f(0, 0, 0);

            GL11.glColor3f(1, 0, 1);
            GL11.glVertex3f(0, 0, 0);
            GL11.glVertex3f(0, 0, 100);
        GL11.glEnd();

        // Render the origin
        this.origin.render();
    }

chunkManager.render() just iterates through each of the loaded chunks and calls .render() on them, which in turn creates a giant solid cube that is rendered at the origin of the chunk.

More code can be provided if needed.

Answer 1

Replace

GL11.glTranslatef(position.x, position.y, position.z);

with

GL11.glTranslatef(-position.x, -position.y, -position.z);

Think about it, you want to be translating the world to the inverse of where the camera is so that that 0,0,0 is where the camera is.