¿Cómo evitar el sangrado de textura en un atlas de textura?

En mi juego hay un terreno similar a Minecraft hecho de cubos. Genero un búfer de vértices a partir de los datos de vóxel y uso un atlas de texturas para la apariencia de diferentes bloques:

El problema es que la textura de cubos distantes se interpola con mosaicos adyacentes en el atlas de texturas. Eso da como resultado líneas de colores incorrectos entre los cubos (es posible que deba ver la captura de pantalla a continuación en su tamaño completo para ver los defectos gráficos):

Por ahora uso esta configuración de interpolación, pero probé todas las combinaciones e incluso GL_NEARESTsin mipmapping no proporciona mejores resultados.

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

También intenté agregar un desplazamiento en las coordenadas de textura para elegir un área ligeramente más pequeña del mosaico, pero dado que el efecto no deseado depende de la distancia a la cámara, esto no puede resolver el problema por completo. A grandes distancias, las rayas ocurren de todos modos.

¿Cómo puedo resolver este sangrado de textura? Dado que el uso de un atlas de texturas es una técnica popular, puede haber un enfoque común. Lamentablemente, por algunas razones explicadas en los comentarios, no puedo cambiar a diferentes texturas o matrices de texturas.

Bien, creo que tienes dos problemas aquí.

El primer problema es con mipmapping. En general, no desea mezclar ingeniosamente atlasing con mipmapping, porque a menos que todas sus subtexturas tengan exactamente un tamaño de 1x1 píxel, experimentará un sangrado de textura. Agregar relleno simplemente moverá el problema a un nivel de mip más bajo.

Como regla general, para 2D, que es donde usualmente haces atlas, no haces mipmap; mientras que para 3D, que es donde mipmap, no atlas (en realidad, tu piel de tal manera que el sangrado no será un problema)

Sin embargo, lo que creo que está sucediendo con su programa en este momento es que probablemente no esté utilizando las coordenadas de textura correctas, y debido a eso sus texturas están sangrando.

Supongamos una textura de 8x8. Probablemente esté obteniendo el cuarto superior izquierdo utilizando coordenadas uv de (0,0) a (0.5, 0.5):

Y el problema es que en la coordenada u 0.5, la muestra interpolará el fragmento de destino utilizando la mitad del texel izquierdo y la mitad del texel derecho. Lo mismo sucederá en la coordenada u 0, y lo mismo para las coordenadas v. Esto se debe a que está abordando los límites entre los texels y no los centros.

Lo que debe hacer en su lugar es abordar el centro de cada texel. En este ejemplo, estas son las coordenadas que desea usar:

En este caso, siempre estará muestreando el centro de cada texel y no debería tener ningún sangrado ... A menos que use mipmapping, en cuyo caso siempre obtendrá sangrado comenzando en el nivel de mip donde la subtextura escalada no se limpia encajar dentro de la cuadrícula de píxeles .

Para generalizar, si desea acceder a un texel específico, las coordenadas se calculan como:

function get_texel_coords(x, y, tex_width, tex_height)
    u = (x + 0.5) / tex_width
    v = (y + 0.5) / tex_height
    return u, v
end

Esto se llama "corrección de medio píxel". Hay una explicación más detallada aquí si está interesado.

Una opción que será mucho más fácil que jugar con mapas MIP y agregar factores de fuzz de coordenadas de textura es usar una matriz de texturas. Las matrices de texturas son similares a las texturas 3d, pero sin mipmapping en la tercera dimensión, por lo que son ideales para atlas de texturas donde las "subtexturas" son todas del mismo tamaño.

http://www.opengl.org/wiki/Array_Texture

Después de luchar mucho con este problema, finalmente encontré una solución.

Para usar ambos, un atlas de texturas y mipmapping, necesito realizar el muestreo por mí mismo, porque OpenGL de lo contrario interpolaría sobre los límites de los mosaicos en el atlas. Además, necesitaba establecer los parámetros de textura correctos, porque la interpolación entre mapas MIP también causaría sangrado de textura.

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

Con estos parámetros, no se produce sangrado.

Hay una cosa que debe tener en cuenta al proporcionar mapas MIP personalizados. Dado que no tiene sentido reducir el atlas incluso si cada mosaico ya lo es 1x1, el nivel máximo de mipmap debe establecerse de acuerdo con lo que proporcione.

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 7); // pick mipmap level 7 or lower

¡Gracias por todas las otras respuestas y comentarios muy útiles! Por cierto, todavía no sé cómo usar el escalamiento lineal, pero supongo que no hay manera.

Parece que el problema podría ser causado por MSAA. Vea esta respuesta y el artículo vinculado :

"cuando activa MSAA, es posible que el sombreador se ejecute para muestras que están dentro del área de píxeles, pero fuera del área del triángulo"

La solución es usar muestreo centroide. Si está calculando el ajuste de las coordenadas de textura en un sombreador de vértices, mover esa lógica al sombreador de fragmentos también podría solucionar el problema.

Este es un tema antiguo, y tuve un problema similar al tema.

Tenía mis coordenadas de textura bien, pero moviendo la posición de la cámara (que cambió las posiciones de mi elemento) así:

public static void tween(Camera cam, Direction dir, Vec2 buffer, Vec2 start, Vec2 end) {
    if(step > steps) {
        tweening = false;
        return;
    }

    final float alpha = step/steps;

    switch(dir) {
    case UP:
    case DOWN:
        buffer = new Vec2(start.getX(), Util.lerp(start.getY(), (float)end.getY(), alpha));
        cam.getPosition().set(buffer);
        break;
    case LEFT:
    case RIGHT:
        buffer = new Vec2(Util.lerp(start.getX(), end.getX(), alpha), start.getY());
        cam.getPosition().set(buffer);
        break;
    }

    step += 1;
}

Todo el problema era Util.lerp () devuelve un flotante o doble. Esto fue malo porque la cámara estaba traduciendo fuera de la red y causando algunos problemas extraños con fragmentos de textura que eran> 0 en X y> 0 en Y.

TLDR: no interpolar ni nada con flotadores