Come evitare il sanguinamento delle trame in un atlante delle trame?

Nel mio gioco c'è un terreno simile a Minecraft fatto di cubi. Genero un buffer di vertici dai dati voxel e utilizzo un atlante di trama per look di blocchi diversi:

Il problema è che la trama di cubi distanti si interpola con tessere adiacenti nell'atlante della trama. Ciò si traduce in linee di colori errati tra i cubi (potrebbe essere necessario visualizzare lo screenshot di seguito a dimensioni intere per vedere i difetti grafici):

Per ora utilizzo queste impostazioni di interpolazione ma ho provato ogni combinazione e anche GL_NEARESTsenza il mipmapping non fornisce risultati migliori.

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

Ho anche provato ad aggiungere un offset nelle coordinate della trama per selezionare un'area leggermente più piccola della piastrella, ma poiché l'effetto indesiderato dipende dalla distanza dalla fotocamera, questo non può risolvere completamente il problema. A grandi distanze le strisce si verificano comunque.

Come posso risolvere questo sanguinamento della trama? Poiché l'utilizzo di un atlante di texture è una tecnica popolare, potrebbe esserci un approccio comune. Purtroppo, per alcuni motivi spiegati nei commenti, non posso passare a trame o matrici di trama diverse.

Ok, penso che tu abbia due problemi qui.

Il primo problema riguarda il mipmapping. In generale, non vuoi mescolare ingenuamente l'atlante con il mipmapping, perché a meno che tutte le sottotesture abbiano dimensioni esattamente di 1 x 1 pixel, si verificherà un sanguinamento della trama. L'aggiunta di un'imbottitura sposta semplicemente il problema a un livello mip inferiore.

Come regola generale, per il 2D, che è dove di solito si fa l'atlante, non si esegue il mipmap; mentre per il 3D, che è dove mipmap, non atlante (in realtà, la pelle in modo tale che il sanguinamento non sarà un problema)

Tuttavia, ciò che penso stia succedendo con il tuo programma in questo momento è che probabilmente non stai usando le coordinate di trama corrette, e per questo motivo le tue trame stanno sanguinando.

Supponiamo che una trama 8x8. Probabilmente stai ottenendo il quarto in alto a sinistra usando le coordinate uv da (0,0) a (0,5, 0,5):

E il problema è che alla coordinata u 0,5, il campionatore interpolerà il frammento di destinazione usando metà del texel sinistro e metà del texel destro. Lo stesso accadrà con la coordinata u 0 e lo stesso per le coordinate v. Questo perché stai affrontando i confini tra texel e non i centri.

Quello che dovresti fare invece è rivolgersi al centro di ogni texel. In questo esempio, queste sono le coordinate che vuoi usare:

In questo caso, campionerai sempre il centro di ogni texel e non dovresti avere alcun sanguinamento ... A meno che tu non usi il mipmapping, nel qual caso otterrai sempre sanguinamento a partire dal livello di mip in cui la sottotitolazione in scala non si adatta in modo ordinato adattarsi alla griglia dei pixel .

Per generalizzare, se si desidera accedere a un texel specifico, le coordinate vengono calcolate come:

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

Questo si chiama "correzione di mezzo pixel". C'è una spiegazione più dettagliata qui se sei interessato.

Un'opzione che sarà molto più semplice che giocherellare con le mipmap e aggiungere i fattori fuzz delle coordinate delle trame è usare un array di trame. Le matrici di trama sono simili alle trame 3d, ma senza mipmapping nella terza dimensione, quindi sono ideali per atlanti di trama in cui le "sottotesture" hanno tutte le stesse dimensioni.

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

Dopo aver lottato molto con questo problema, ho finalmente trovato una soluzione.

Per usare entrambi, un atlante di texture e un mipmapping, ho bisogno di eseguire il downsampling me stesso, perché OpenGL altrimenti interpolerebbe oltre i confini delle piastrelle nell'atlante. Inoltre, avevo bisogno di impostare i giusti parametri di trama, perché l'interpolazione tra le mipmap avrebbe anche causato sanguinamenti di trama.

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

Con questi parametri, non si verificano sanguinamenti.

C'è una cosa che devi notare quando fornisci mipmap personalizzate. Poiché non ha senso ridurre l'atlante anche se ogni riquadro è già 1x1, il livello massimo di mipmap deve essere impostato in base a ciò che si fornisce.

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

Grazie per tutte le altre risposte e commenti molto utili! A proposito, non so ancora come usare il ridimensionamento lineare, ma suppongo che non ci sia modo.

Sembra che il problema potrebbe essere causato da MSAA. Vedi questa risposta e l' articolo collegato :

"quando attivi MSAA, diventa possibile che lo shader venga eseguito per campioni che si trovano all'interno dell'area pixel, ma al di fuori dell'area triangolare"

La soluzione è utilizzare il campionamento del centroide. Se stai calcolando il wrapping delle coordinate della trama in uno shader di vertici, spostare la logica nello shader di frammenti potrebbe anche risolvere il problema.

Questo è un vecchio argomento e ho avuto un problema simile all'argomento.

Le coordinate della trama erano perfette, ma modificando la posizione della videocamera (che ha cambiato la posizione del mio elemento) in questo modo:

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

L'intero problema era che Util.lerp () restituiva un float o un double. Questo è stato negativo perché la fotocamera stava traducendo off-grid e causando alcuni strani problemi con i frammenti di trama in cui> 0 in X e> 0 in Y.

TLDR: non interpolare o altro usando i float