Como posso escalar as texturas do OpenGL sem embaçar?

Estou usando o OpenGL através do LWJGL.

Eu tenho uma renderização quad texturada 16x16 em 16x16. Quando altero o valor da escala, o quad cresce e fica mais desfocado à medida que aumenta.

Como posso escalar sem ficar embaçado, como no Minecraft.

Aqui está o código dentro do meu objeto RenderableEntity:

public void render(){       
    Color.white.bind();
    this.spriteSheet.bind();        
    GL11.glBegin(GL11.GL_QUADS);
        GL11.glTexCoord2f(0,0);
        GL11.glVertex2f(this.x, this.y);
        GL11.glTexCoord2f(1,0);
        GL11.glVertex2f(getDrawingWidth(), this.y);
        GL11.glTexCoord2f(1,1);
        GL11.glVertex2f(getDrawingWidth(), getDrawingHeight());
        GL11.glTexCoord2f(0,1);
        GL11.glVertex2f(this.x, getDrawingHeight());
     GL11.glEnd();

}

E aqui está o código do meu método initGL na minha classe de jogo

GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glClearColor(0.46f,0.46f,0.90f,1.0f);
GL11.glViewport(0,0,width,height);
GL11.glOrtho(0,width,height,0,1,-1);

E aqui está o código que faz o desenho real

public void start(){
    initGL(800,600);
    init();

    while(true){
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

        for(int i=0;i<entities.size();i++){
            ((RenderableEntity)entities.get(i)).render();
        }

        Display.update();
        Display.sync(100);

        if(Display.isCloseRequested()){
            Display.destroy();
            System.exit(0);
        }
    }
}

Você precisa alterar o tipo de ampliação da textura, assim:

 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

Leia sobre glTexParameter .

Você não pode. A natureza de qualquer tipo de dados digitais é que, depois que as informações são removidas, elas nunca podem ser devolvidas e, da mesma forma, você não pode preencher informações que nunca existiram. Em primeiro lugar, o melhor que você pode fazer é uma aproximação aproximada, o que lhe dá embaçamento.

O uso de GL_NEAREST não será desfocado, mas será pixelado.

A solução é usar uma textura maior com mipmaps. Dessa forma, você obtém boa qualidade, independentemente do tamanho da geometria que está sendo texturizada.

Eu experimentei esse problema em primeira mão - criando um jogo baseado em bloco com texturas de baixa resolução (8px * 8px). Não importa o quão perto ou o quão longe a câmera estivesse, as texturas estavam sendo cruzadas "misturadas" pelas configurações padrão do OpenGL - elas pareciam embaçadas.

Você precisa ativar a ampliação "mais próxima" para desativar a filtragem bilinear. Ou seja, quando a câmera é ampliada perto da textura; cada pixel é definido como a cor do texel mais próximo - sem mistura.

Você faz isso com estas duas linhas:

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);