Was ist der beste Weg, um ein Vollbild -Quad in OpenGL 3.2 zu zeichnen?

Question

Ich mache Ray Casting im Fragment -Shader. Ich kann mir ein paar Möglichkeiten vorstellen, ein Vollbildquad für diesen Zweck zu zeichnen. Zeichnen Sie entweder einen Quad im Clip -Raum mit der Projektionsmatrix, die auf die Identitätsmatrix eingestellt ist, oder verwandeln Sie den Geometrie -Shader, um einen Punkt in einen Dreieck -Streifen zu verwandeln. Ersteres verwendet den sofortigen Modus, veraltet in OpenGL 3.2. Letzteres benutze ich aus Neuheit, aber es verwendet immer noch den sofortigen Modus, um einen Punkt zu ziehen.

Answer 1

Sie können zwei Dreiecke schicken, die ein Quad erstellen, wobei die Scheitelpunktattribute auf -1/1 eingestellt sind.

Sie müssen sie nicht mit einer Matrix im Scheitelpunkt/Fragment -Shader multiplizieren.

Hier sind einige Code -Beispiele, einfach so :)

Scheitelpunkt Shader:

const vec2 madd=vec2(0.5,0.5);
attribute vec2 vertexIn;
varying vec2 textureCoord;
void main() {
   textureCoord = vertexIn.xy*madd+madd; // scale vertex attribute to [0-1] range
   gl_Position = vec4(vertexIn.xy,0.0,1.0);
}

Fragment Shader:

varying vec2 textureCoord;
void main() {
   vec4 color1 = texture2D(t,textureCoord);
   gl_FragColor = color1;
}

Answer 2

Um einen Vollbild -Quad -Geometrie -Shader auszugeben, kann verwendet werden:

#version 330 core

layout(points) in;
layout(triangle_strip, max_vertices = 4) out;

out vec2 texcoord;

void main() 
{
    gl_Position = vec4( 1.0, 1.0, 0.5, 1.0 );
    texcoord = vec2( 1.0, 1.0 );
    EmitVertex();

    gl_Position = vec4(-1.0, 1.0, 0.5, 1.0 );
    texcoord = vec2( 0.0, 1.0 ); 
    EmitVertex();

    gl_Position = vec4( 1.0,-1.0, 0.5, 1.0 );
    texcoord = vec2( 1.0, 0.0 ); 
    EmitVertex();

    gl_Position = vec4(-1.0,-1.0, 0.5, 1.0 );
    texcoord = vec2( 0.0, 0.0 ); 
    EmitVertex();

    EndPrimitive(); 
}

Der Scheitelpunkt -Shader ist einfach leer:

#version 330 core

void main()
{
}

Um diesen Shader zu verwenden, können Sie den Befehl Dummy Draw mit leerem VBO verwenden:

glDrawArrays(GL_POINTS, 0, 1);

Answer 3

Ein Hinweis von Chistophe Riccio:

Ein großes Dreieck ist effizienter, aus Gründen, die ich in Videos illustriert habe:

http://www.youtube.com/watch?v=wfx6stqprdy

http://www.youtube.com/watch?v=wnus8kza3di&feature=related

Answer 4

Sie müssen keinen Geometrie -Shader, einen VBO oder einen Speicher verwenden.

Ein Scheitelpunkt -Shader kann das Quad erzeugen.

layout(location = 0) out vec2 uv;

void main() 
{
    float x = float(((uint(gl_VertexID) + 2u) / 3u)%2u); 
    float y = float(((uint(gl_VertexID) + 1u) / 3u)%2u); 

    gl_Position = vec4(-1.0f + x*2.0f, -1.0f+y*2.0f, 0.0f, 1.0f);
    uv = vec2(x, y);
}

Binden Sie einen leeren Vao. Senden Sie einen Ziehanruf für 6 Scheitelpunkte.

Answer 5

Das Folgende kommt aus der Zeichnung der Klasse der Klasse, die FBO -Texturen zu einem Bildschirm ausgerichtet ist.

Gl.glUseProgram(shad);      

Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, vbo);           
Gl.glEnableVertexAttribArray(0);
Gl.glEnableVertexAttribArray(1);
Gl.glVertexAttribPointer(0, 3, Gl.GL_FLOAT, Gl.GL_FALSE, 0, voff);
Gl.glVertexAttribPointer(1, 2, Gl.GL_FLOAT, Gl.GL_FALSE, 0, coff);  

Gl.glActiveTexture(Gl.GL_TEXTURE0);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, fboc);
Gl.glUniform1i(tileLoc, 0);

Gl.glDrawArrays(Gl.GL_QUADS, 0, 4);

Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, 0); 

Gl.glUseProgram(0); 

Das tatsächliche Quad selbst und die Koordnungen stammen aus:

private float[] v=new float[]{  -1.0f, -1.0f, 0.0f,
                                1.0f, -1.0f, 0.0f,
                                1.0f, 1.0f, 0.0f,
                                -1.0f, 1.0f, 0.0f,

                                0.0f, 0.0f,
                                1.0f, 0.0f,
                                1.0f, 1.0f,
                                0.0f, 1.0f
};

Die Bindung und Einstellung der VBOs überlasse ich Ihnen.

Der Scheitelpunkt Shader:

#version 330

layout(location = 0) in vec3 pos;
layout(location = 1) in vec2 coord;

out vec2 coords;

void main() {
    coords=coord.st;
    gl_Position=vec4(pos, 1.0);
}

Weil die Position roh ist, dh nicht mit einer Matrix multipliziert, die -1, -1 :: 1, 1 des Quad -Pitchs in das Ansichtsfenster. Suchen Sie nach Alfonse's Tutorial, das einen seiner Beiträge auf OpenGL.org verknüpft hat.