When doing GPU programming, it’s sometimes useful to determine the positions of the vertices of the current triangle primitive in a fragment shader. The usual advice here is to use a geometry or tessellation shader to gather up the positions and pass them along explicitly to the fragment shader. It turns out, though, that there is a relatively straightforward solution without any extra shader stages using the standard derivative functions dFdx and dFdy. It works as long as the (non-perspective-correct) barycentric coordinates for the current fragment are available. I’m sure I’m not the first one to come up with this technique, but a quick search didn’t find any explanations of it, so I thought I’d write it up, because it turned out to be useful in Pathfinder.

An important caveat applies: Make sure that you’re sure you need to do this. It’s easy to go wild with this technique and end up with more varyings than the simple solution would call for. In general, this technique is most useful when it saves a geometry or tessellation shader invocation.

Here I assume that the barycentric coordinates of the current fragment are known. They must sum to 1, so it suffices to know two of them to compute the other one. If you need barycentric coordinates and cannot compute them from other varyings you have around, then you can pass them to the fragment shader by declaring noperspective in vec2 vLambda; and setting vLambda to , , and for the first, second, and third vertices respectively. We also need the gradients and . Following the example above, the function dFdx(vLambda) will yield , and dFdy(vLambda) will yield .

Let be the screen-space position of the current fragment (i.e. gl_FragCoord), and let and be the positions of the fragments to the immediate right and above, respectively. , , and are the barycentric coordinates of the current fragment; likewise, , , and are those of the fragment to the right, and , , and are those of the fragment above.

We know that for all triangle vertices , , and . Putting it all together, we formulate a system of equations:

After some algebra and the application of Cramer’s rule, we get:

Notice that shows up over and over again in these formulas. That value is the Jacobian determinant . Using to represent the row vector , we can more succinctly rewrite the above as:

Along with point positions, sometimes the triangle edge vectors , , and are useful. These have even simpler formulas:

The expressions for the vectors (for vertices ) are straightforward as well:

Below is some GLSL code to compute screen-space triangle vertex positions from and (as lambda.x and lambda.y respectively).

    void vertexPositions(out vec2 outV0,
                         out vec2 outV1,
                         out vec2 outV2,
                         vec2 fragCoord,
                         vec2 lambda) {
        mat2 j = mat2(dFdx(lambda), dFdy(lambda));
        float detJ = determinant(j);
        vec2 detXY = vec2(determinant(mat2(j[1], lambda)),
                          determinant(mat2(lambda, j[0])));
        vec2 v = detJ * fragCoord + detXY;
        outV0 = (v + vec2(j[1][1], -j[0][1])) / detJ;
        outV1 = (v + vec2(-j[1][0], j[0][0])) / detJ;
        outV2 = v / detJ;