¿Cómo puedo hacer que las texturas OpenGL escalen sin volverse borrosas?

Estoy usando OpenGL a través de LWJGL.

Tengo una representación cuádruple texturizada de 16x16 a 16x16. Cuando cambio su cantidad de escala, el quad crece, luego se vuelve más borroso a medida que se hace más grande.

¿Cómo puedo hacer que escale sin volverse borroso, como en Minecraft?

Aquí está el código dentro de mi 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();

}

Y aquí está el código de mi método initGL en mi clase de juego

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);

Y aquí está el código que hace el dibujo 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);
        }
    }
}

Necesita cambiar el tipo de aumento de la textura, así:

 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

Lea sobre glTexParameter .

No puedes La naturaleza de cualquier tipo de datos digitales es que una vez que se ha eliminado la información, nunca se puede volver a colocar, y de la misma manera no se puede completar la información que nunca estuvo allí en primer lugar; lo mejor que puede hacer es una aproximación aproximada, lo que te da borrosidad.

El uso de GL_NEAREST no se desenfocará, sino que se volverá pixelado.

La solución es usar una textura más grande con mipmaps. De esa manera, obtienes buena calidad sin importar el tamaño de la geometría que se está texturizando.

He experimentado este problema de primera mano: hacer un juego basado en bloques con texturas de baja resolución (8px * 8px). No importa qué tan cerca o qué tan lejos estuviera la cámara, las texturas se estaban "mezclando" de forma cruzada por la configuración predeterminada de OpenGL: parecían borrosas.

Debe habilitar la ampliación "más cercana" para deshabilitar el filtrado bilineal. Es decir, cuando la cámara se acerca a la textura; cada píxel se define como el color del texel más cercano, sin fusión.

Haces esto con estas dos líneas:

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