CODEWITHSUNDEEP
javaopengldrawlwjgltile
grantperry
grantperry

Reputation: 149

LWJGL glTranslate doing weird things

this is a big problem I have been running into.

I am trying to render multiple tiles using glTranslate but when I call my draw function with the x, y coordinates the tiles are spaced weirdly(I don't want spaces).

Here is what happens.

Drawing multiple tiles but having problems

here is my code:

Draw:

public void draw(float Xa, float Ya) {

    GL11.glTranslatef(Xa, Ya, 0);


    if(hasTexture) {
    Texture.bind();

    GL11.glBegin(GL11.GL_QUADS);
        GL11.glColor3f(0.5f, 0.5f, 1);
        GL11.glTexCoord2f(0, 0);
        GL11.glVertex2f(0, 0);
        GL11.glTexCoord2f(0, 1);
        GL11.glVertex2f(0, S);
        GL11.glTexCoord2f(1, 1);
        GL11.glVertex2f(S, S);
        GL11.glTexCoord2f(1, 0);
        GL11.glVertex2f(S, 0);

        GL11.glEnd();
    }

and my render code:

public void a() throws IOException {
    GL11.glTranslatef(0, 0, -10);
    int x = 0;
    while (x < World.BLOCKS_WIDTH - 1) {
        int y = 0;
        while (y < World.BLOCKS_HEIGHT - 1) {
            blocks.b[data.blocks[x][y]].draw(x, y);
            y++;
        }
        x++;
}

there are no errors (except the visible ones)

Upvotes: 1

Views: 1242

Answers (1)

JasonD
JasonD

Reputation: 16582

You do not appear to be initialising or pushing / popping the current transform. So the translations will accumulate, producing the effect you see, getting further and further apart as you translate by ever larger values.

Lets say your blocks are 10 units apart. The first is drawn with a translation of (0, 0), then next (0, 10), then (0, 20), (0, 30), etc.

However as the translations accumulate in the view matrix, what you actually get are translations of (0,0), (0,10), (0,30), (0,60), etc.

This is important, as it allows you to build a complex transform from a series of simple discrete steps. However when you want to render multiple objects, each with their own transform, you need to have some form of reset in between each object.

You could reinitialise the whole matrix, but that's a bit untidy and involves knowing what other transforms (such as the camera, etc.) have been done previously.

Instead, you can "push" the current matrix onto a stack, perform whatever local transformations you want to do, render stuff, and then "pop" the matrix back off so that you're back where you started, ready to render the next object.

I should point out that all this functionality is deprecated in the later versions of GL. With the more modern API you use shaders, and can supply whatever transforms you care to calculate.

Upvotes: 4

Related Questions