Uniform point array e gestione dei sistemi di coordinate dello shader di frammenti

Question

Il mio obiettivo è passare una serie di punti allo shader, calcolare la loro distanza dal frammento e dipingerli con un cerchio colorato con un gradiente a seconda del calcolo.

Ad esempio:

(Da una working example I set up on shader toy)

Purtroppo non è chiaro per me come dovrei calcolare e convertire le coordinate passati per l'elaborazione all'interno del shader.

Quello che sto provando attualmente è passare due array di float - uno per le posizioni x e uno per le posizioni y di ciascun punto - allo shader anche se uniforme. Poi dentro lo shader scorrere ogni punto in questo modo:

#ifdef GL_ES 
precision mediump float; 
precision mediump int; 
#endif 

uniform float sourceX[100]; 
uniform float sourceY[100]; 
uniform vec2 resolution; 

in vec4 gl_FragCoord; 

varying vec4 vertColor; 
varying vec2 center; 
varying vec2 pos; 

void main() 
{ 
    float intensity = 0.0; 

    for(int i=0; i<100; i++) 
    { 
     vec2 source = vec2(sourceX[i],sourceY[i]); 
     vec2 position = (gl_FragCoord.xy/resolution.xy); 
     float d = distance(position, source); 
     intensity += exp(-0.5*d*d); 
    } 

    intensity=3.0*pow(intensity,0.02); 

    if (intensity<=1.0) 
     gl_FragColor=vec4(0.0,intensity*0.5,0.0,1.0); 
    else if (intensity<=2.0) 
     gl_FragColor=vec4(intensity-1.0, 0.5+(intensity-1.0)*0.5,0.0,1.0); 
    else 
     gl_FragColor=vec4(1.0,3.0-intensity,0.0,1.0); 
} 

Ma questo non funziona - e credo che può essere perché sto cercando di lavorare con le coordinate di pixel senza tradurli correttamente. Qualcuno potrebbe spiegarmi come farlo funzionare?

Aggiornamento:

Il risultato corrente è: codice del disegno è:

PShader pointShader; 

float[] sourceX; 
float[] sourceY; 


void setup() 
{ 

    size(1024, 1024, P3D); 
    background(255); 

    sourceX = new float[100]; 
    sourceY = new float[100]; 
    for (int i = 0; i<100; i++) 
    { 
    sourceX[i] = random(0, 1023); 
    sourceY[i] = random(0, 1023); 
    } 


    pointShader = loadShader("pointfrag.glsl", "pointvert.glsl"); 
    shader(pointShader, POINTS); 
    pointShader.set("sourceX", sourceX); 
    pointShader.set("sourceY", sourceY); 
    pointShader.set("resolution", float(width), float(height)); 
} 


void draw() 
{ 
    for (int i = 0; i<100; i++) { 
    strokeWeight(60); 
    point(sourceX[i], sourceY[i]); 
    } 
} 

mentre il vertex shader è:

#define PROCESSING_POINT_SHADER 

uniform mat4 projection; 
uniform mat4 transform; 


attribute vec4 vertex; 
attribute vec4 color; 
attribute vec2 offset; 

varying vec4 vertColor; 
varying vec2 center; 
varying vec2 pos; 

void main() { 

    vec4 clip = transform * vertex; 
    gl_Position = clip + projection * vec4(offset, 0, 0); 

    vertColor = color; 
    center = clip.xy; 
    pos = offset; 
} 

Answer 1

Aggiornamento:

Sulla base delle osservazioni sembra aver confuso due diversi approcci:

1. disegnare un singolo poligono pieno schermo, passare nei punti e calcolare il valore finale una volta per ogni frammento utilizzando un ciclo nello shader.
2. Disegnare la geometria di delimitazione per ciascun punto, calcolare la densità per un solo punto nello shader di frammenti e utilizzare la miscelazione additiva per sommare le densità di tutti i punti.

L'altro problema è che i punti sono espressi in pixel ma il codice prevede un intervallo da 0 a 1, quindi d è grande ei punti sono neri. Risolvere questo problema come @RetoKoradi describes dovrebbe risolvere i punti neri, ma ho il sospetto che troverai problemi di clipping rampa quando molti sono nelle immediate vicinanze. Passare punti nello shader limita la scalabilità ed è inefficiente a meno che i punti coprano l'intera finestra.

Come di seguito, penso che attenersi all'approccio 2 sia migliore. Di ristrutturare il codice per esso, rimuovere il loop, non passare nella matrice di punti e utilizzare center come punto di coordinate invece:

//calc center in pixel coordinates 
vec2 centerPixels = (center * 0.5 + 0.5) * resolution.xy; 

//find the distance in pixels (avoiding aspect ratio issues) 
float dPixels = distance(gl_FragCoord.xy, centerPixels); 

//scale down to the 0 to 1 range 
float d = dPixels/resolution.y; 

//write out the intensity 
gl_FragColor = vec4(exp(-0.5*d*d)); 

Draw this to a texture (da osservazioni: opengl-tutorial.orgcode e this question) con additivo blending:

glEnable(GL_BLEND); 
glBlendFunc(GL_ONE, GL_ONE); 

Ora che trama conterrà intensity come è stato dopo il ciclo originale.In un'altra Shader frammento durante un passaggio a schermo intero (trascinare un triangolo che copre l'intera finestra), continua con:

uniform sampler2D intensityTex; 
... 
float intensity = texture2D(intensityTex, gl_FragCoord.xy/resolution.xy).r; 
intensity = 3.0*pow(intensity, 0.02); 
... 

---

Il codice avete mostrato è soddisfacente, supponendo che si sta tracciando una completo schermo poligono in modo che lo shader di frammenti venga eseguito una volta per ogni pixel. Potenziali problemi sono:

• resolution non è impostato correttamente
• Le coordinate del punto non sono nel range 0-1 sullo schermo.
• Anche se di minore importanza, lo d verrà allungato dal rapporto aspetto, quindi è possibile che sia meglio ridimensionare i punti fino alle coordinate dei pixel e alla distanza di immersione entro resolution.y.

Sembra molto simile alla creazione di un campo di densità per 2D metaballs. Per le prestazioni, è meglio limitare la funzione di densità per ogni punto in modo che non avvenga per sempre, quindi spargere i dischi in una texture utilizzando la miscelazione aggiuntiva. Questo risparmia l'elaborazione di quei pixel che un punto non ha effetto (proprio come nelle sfumature differite). Il risultato è il campo di densità, o nel tuo caso per-pixel intensity.

questi sono un po 'correlato:

• 2D OpenGL ES Metaballs on android (nessuna risposta)
• calculate light volume radius from intensity
• gl_PointSize Corresponding to World Space Size

Answer 2

Sembra che il punto centrale e la posizione frammento sono in diversi spazi di coordinate quando le sottrai:

vec2 source = vec2(sourceX[i],sourceY[i]); 
vec2 position = (gl_FragCoord.xy/resolution.xy); 
float d = distance(position, source); 

In base alla spiegazione e al codice, source e source sono in coordinate di finestra, ovvero in unità di pixel. gl_FragCoord si trova nello stesso spazio di coordinate. E anche se non lo mostri direttamente, suppongo che resolution sia la dimensione della finestra in pixel.

Questo significa che:

vec2 position = (gl_FragCoord.xy/resolution.xy); 

calcola la posizione normalizzata del frammento all'interno della finestra, nell'intervallo [0.0, 1.0] per xey. Ma poi nella riga successiva:

float d = distance(position, source); 

si subtrace source, che è ancora in coordinate finestra, da questa posizione in coordinate normalizzate.

Poiché sembra che si voleva la distanza in coordinate normalizzate, che ha un senso, avrete anche bisogno di normalizzare source:

vec2 source = vec2(sourceX[i],sourceY[i])/resolution.xy;