È possibile utilizzare gli sprite di punti OpenGL per simulare gli sprite dei tabelloni?

Question

Stavo cercando di impostare sprite puntiformi in OpenGL per modificare le dimensioni con la distanza proprio come farebbe uno sprite cartellone, ma non riesco a ottenere i valori in GL_POINT_DISTANCE_ATTENUATION_ARB per fare qualcosa di utile. Esiste una correlazione di valori con questa che corrisponderebbe a una data proiezione? Quello che sto cercando di fare è anche possibile?

Render codice utilizzato:

glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)wglGetProcAddress("glPointParameterfARB"); 
glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)wglGetProcAddress("glPointParameterfvARB"); 

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 
glLoadIdentity(); 
gluPerspective(100.0, 800.0/600.0, 0.1, 10.0); 

float quadratic[] = { 5.0f, 0.1f, 10.0f }; 
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic); 

float maxSize = 0.0f; 
glGetFloatv(GL_POINT_SIZE_MAX_ARB, &maxSize); 
if(maxSize > 100.0f) maxSize = 100.0f; 
glPointSize(maxSize); 

glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.1f); 
glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 0.1f); 
glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, maxSize); 

glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE); 

glEnable(GL_POINT_SPRITE_ARB); 

glScalef(0.75,1,1); 
glTranslatef(0.00,0.0,-1.0); 
glScalef(0.5,0.5,0.5); 
glRotatef(counter*0.1+0.5,1.0,1.0,0.0); 

glBegin(GL_POINTS); 

for(int i = 0; i < 100; ++i) 
{ 
    glColor4f(i%10*0.1, i/10*0.1, 0.5, 1.0f); 

    glVertex3f(i%10*0.2-1.0,i/10*0.2-1.0, 
    ((i%10-5)*(i%10-5)+(i/10-5)*(i/10-5))*0.01); 
} 

glEnd(); 

glDisable(GL_POINT_SPRITE_ARB); 

Answer 1

Ecco come faccio l'approccio del mio povero uomo a scalare le dimensioni in punti:

void render() { 
    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB); 
    glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); 
    glEnable(GL_POINT_SPRITE); 
    glActiveTexture(GL_TEXTURE0); 
    glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE); 

    /* Activate shader program here */ 
    /* Send pointSize to shader program */ 

    glBegin(GL_POINTS); 
     /* Render points here */ 
     glVertex3f(...); 
    glEnd(GL_POINTS); 
} 

Vertex Shader:

uniform float pointSize; 
void main() { 
    gl_Position = ftransform(); 
    gl_PointSize = pointSize/gl_Position.w; 
} 

Si può fare quello che vuoi nello shader frammento, ma dovrete devi calcolare il colore, l'illuminazione e texturing te stesso.

Answer 2

Nella mia esperienza dimensione in punti attenuazione è non vale la pena. È molto meglio scrivere un vertex shader GLSL molto semplice che imposta manualmente la dimensione del punto in base ad alcuni calcoli eseguiti da soli. Mi ci è voluta circa mezza giornata per imparare da zero tutto il GLSL di cui avevo bisogno per farlo accadere.

Il codice GLSL può essere semplice come queste poche righe:

attribute float psize; 

void main() 
{ 
    gl_FrontColor = gl_Color; 
    gl_PointSize = psize; 
    gl_Position = ftransform(); 
} 

Dove psize è il parametro di dimensione punto l'utente sceglie.

Answer 3

GLSL a parte, fare quello che vuoi è piuttosto semplice con l'attenuazione della distanza. Vedendo come la dimensione proiettata delle cose diminuisce quadraticamente con la loro distanza nelle proiezioni prospettiche, è sufficiente utilizzare il fattore quadratico.

Se si desidera utilizzare la dimensione del punto impostata manualmente a una distanza di, ad esempio, 150 unità dall'occhio, utilizzare solo 1/(150^2) come fattore quadratico (e zero per i fattori costanti e lineari - semmai, potresti voler usare un piccolo numero come 0,01 per il fattore costante solo per evitare potenziali divisioni per zero).

Answer 4

Basta dare un'occhiata in pmviewer.sourceforge.net il codice sta usando sprite punto e ogni punto ha un proprio colore e dimensione per simulare il rendering volumetrico: Il vertex shader è:

Vertexshader

// with ATI hardware, uniform variable MUST be used by output 
    // variables. That's why win_height is used by gl_FrontColor 
    attribute float a_hsml1; 
    uniform float win_height; 
    uniform vec4 cameralocin; 
    void main() 
    { 
    vec4 position=gl_ModelViewMatrix*gl_Vertex; 
    vec4 cameraloc=gl_ModelViewMatrix*cameralocin; 
    float d=distance(vec3(cameraloc),vec3(position)); 
    float a_hsml=gl_Normal.x; 
    float pointSize=win_height*a_hsml/d; // <- point diameter in 
             //pixels (drops like sqrt(1/r^2)) 
    gl_PointSize=pointSize; 
    gl_TexCoord[0]=gl_MultiTexCoord0; 
    gl_Position=ftransform(); 
    gl_FrontColor=vec4(gl_Color.r,gl_Color.g,gl_Color.b,gl_Color.a); 
    } 

PixelShader

uniform sampler2D splatTexture; 
void main() 
{ 
vec4 color = gl_Color * texture2D(splatTexture, gl_TexCoord[0].st); 
gl_FragColor = color;\n" 
} 

Basta inviare particelle gpu:

void PutOneArrayToGPU(unsigned int m_vbo, float *hArray, unsigned int num) 
{ 
glBindBuffer(GL_ARRAY_BUFFER, m_vbo); 
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * num, hArray, GL_STATIC_DRAW); 
int size = 0; 
glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &size); 
if ((unsigned)size != (sizeof(float) *num)) 
    { 
    fprintf(stderr, "WARNING: Pixel Buffer Object allocation failed!\n"); 
    fprintf(stderr, "TurningOff the GPU accelerated rendering\n"); 
    flag_GpuRender=false; 
    } 
return flag_GpuRender; 
} 

Poi li renda:

void DrawPointsByGPU() 
    { 
    glEnableClientState(GL_VERTEX_ARRAY); 
    glBindBuffer(GL_ARRAY_BUFFER, m_vboPos); 
    glVertexPointer(3, GL_FLOAT, 0, 0); 

    glEnableClientState(GL_COLOR_ARRAY); 
    glBindBuffer(GL_ARRAY_BUFFER, m_vboColor); 
    glColorPointer(4, GL_FLOAT, 0, 0); 

    glEnableClientState(GL_NORMAL_ARRAY); 
    glBindBuffer(GL_ARRAY_BUFFER, m_vboHSML); 
    glNormalPointer(GL_FLOAT, 3*sizeof(float), 0); 

    glDrawArrays(GL_POINTS, 0, m_numParticles); 

    glBindBuffer(GL_ARRAY_BUFFER, 0); 
    glDisableClientState(GL_NORMAL_ARRAY); 
    glDisableClientState(GL_COLOR_ARRAY); 
    glDisableClientState(GL_VERTEX_ARRAY); 

    };