CODEWITHSUNDEEP
positionscreenglslshadervertex
user1822451
user1822451

Reputation: 111

equivalent to gl_FragCoord in glsl vertex shader

I'm trying to get a screen position of a vertex in pixels inside a vertex shader, I saw some others posts here but I can't find answer that works for me. this is what I've got in my vertex Shader:

#version 400
layout (location = 0) in vec3 inPosition;
uniform mat4 MVP; // modelViewProjection
uniform vec2 window;

void main()
{
    // vertex in screen space
    vec2 fake_frag_coord = (MVP * vec4(inPosition,1.0)).xy;
    float X = (fake_frag_coord.x*window.x/2.0) + window.x;
    float Y = (fake_frag_coord.y*window.y/2.0) + window.y;
}

It's not working very well and I know it's a strange think to do inside a vertex shader but I want to multiply my vertex offset by a 2d texture, so I need to find the pixel the vertex is on top to be able to multiply it by the pixel of the texture.

thanks! Luiz

Upvotes: 1

Views: 3441

Answers (3)

Robert Rodriguez
Robert Rodriguez

Reputation: 191

If you want to get this working on the js part of things, this is how I adapted Andon M. Coleman's reply:

var winW = window.innerWidth;
var winH = window.innerHeight;

camera.updateProjectionMatrix();
// Not sure about the order of these! I was using orthographic camera so it didn't matter but double check the order if it doesn't work!
var MVP = camera.projectionMatrix.multiply(camera.matrixWorldInverse);

// position to vertex clip-space
var fake_frag_coord = position.applyMatrix4(MVP);                       // Range:   [-w,w]^4

// vertex to NDC-space
fake_frag_coord.x = fake_frag_coord.x / fake_frag_coord.w;  // Rescale: [-1,1]^3
fake_frag_coord.y = fake_frag_coord.y / fake_frag_coord.w;  // Rescale: [-1,1]^3
fake_frag_coord.z = fake_frag_coord.z / fake_frag_coord.w;  // Rescale: [-1,1]^3
fake_frag_coord.w = 1.0 / fake_frag_coord.w;                                // Invert W

// Vertex in window-space
fake_frag_coord.x = fake_frag_coord.x * 0.5;
fake_frag_coord.y = fake_frag_coord.y * 0.5;
fake_frag_coord.z = fake_frag_coord.z * 0.5;

fake_frag_coord.x = fake_frag_coord.x + 0.5;
fake_frag_coord.y = fake_frag_coord.y + 0.5;
fake_frag_coord.z = fake_frag_coord.z + 0.5;

// Scale and Bias for Viewport (We want the window coordinates, so no need for this)
fake_frag_coord.x = fake_frag_coord.x / winW;
fake_frag_coord.y = fake_frag_coord.y / winH;

Upvotes: 0

derhass
derhass

Reputation: 45332

I think Andon M. Coleman's answer is fine. However, I like to point out a more general issue with the approach discussed in the question: there might be no meaningful screen space position for a vertex at all.

The vertex might lie utside the viewing frustum. This will not be a a problem if the vertices you draw are guaranteed to lie in the frustum, or if you are drawing only points.

But it will fail if you have primitives intersecting the near plane. You might think that in such a case, you just get some coordinates which are outside [-1,1] in NDC space, and if you just use them to assign some output value for the vertex, the clipping state will make it right. But that assumption is wrong. You might values which are pefectly in [-1,1] in NDC space even for vertices which are outside the frustum, and it it will appear as if the vertices lie in front of the camera for all vertices wich actually lie behind the camera. And no subsequent clipping stage is able to fix this.

The only way to get this right would be to actually carry out the clipping operation, before doing the divide by w. And this is something you don't want to do in a vertex shader.

Upvotes: 1

Andon M. Coleman
Andon M. Coleman

Reputation: 43319

I have corrected your vertex shader with proper terms, and shown you the exact sequence of transformations that actually happens when GL computes gl_FragCoord (window-space).

#version 400
layout (location = 0) in vec4 inPosition; // Always use vec4, it makes life easier!
uniform mat4 MVP; // modelViewProjection
uniform vec2 window;

void main()
{
    // Vertex in clip-space
    vec4 fake_frag_coord  = (MVP * inPosition);     // Range:   [-w,w]^4

    // Vertex in NDC-space
    fake_frag_coord.xyz /= fake_frag_coord.w;       // Rescale: [-1,1]^3
    fake_frag_coord.w    = 1.0 / fake_frag_coord.w; // Invert W

    // Vertex in window-space
    fake_frag_coord.xyz *= vec3 (0.5) + vec3 (0.5); // Rescale: [0,1]^3
    fake_frag_coord.xy  *= window;                  // Scale and Bias for Viewport

    // Assume depth range: [0,1] --> No need to adjust fake_frag_coord.z

    [...]
}

Texture coordinates and window-space coordinates are very different things, however. Generally you need normalized coordinates for traditional texture fetches, that means you want the coordinates in the range [0,1].

Luckily window-space and texture-space share the same origin convention (0,0) = bottom-left, so you can cut out the line below to get the appropriate texture coordinates:

    fake_frag_coord.xy  *= window;                  // Scale and Bias for Viewport

Upvotes: 1

Related Questions