UNITY_MATRIX_MVP Is not in homogeneous coordinates?

Unity Engine
1

I have troubles understanding how unity’s screen space coordinates work.
Let me illustrate my confusion. I have created basic scene with one cube and Unlit shader attached to it, which I modified to return the result of o.vertex = mul(UNITY_MATRIX_MVP, float4(v.vertex));
And this is the result I get:

3031614--226788--NotScaled.png
3031614--226788--NotScaled.png984×665 20.9 KB

Obviously x, y coordinates are too high and not scaled from 0 to 1

Therefore, in the next test I divide i.vertex.xy by Screen Width and get this result :

3031614--226789--Scaled.png
3031614--226789--Scaled.png982×667 21.8 KB

Why UNITY_MATRIX_MVP returns coordinates in screen pixel space? These are not homogeneous coordinates that I would expect from the same operation in OpenGL or Direct3D.

Shader "Unlit/TestCoord"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog
           
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
           
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, float4(v.vertex));
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);
                return o;
            }
           
            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = fixed4(i.vertex.xy, 0.0, 1.0) ;
                return col;
            }
            ENDCG
        }
    }
}

3031614--226789--Scaled.png
3031614--226789--Scaled.png982×667 21.8 KB

2

It’s not in screen pixels, but you’ll have to perform the perspective divide by dividing by w. Exactly the same as in DirectX and OpenGL by the way.

From wikipedia:
“In homogeneous coordinates, the point (x, y, z) is represented by (xw, yw, zw, w).”

3

Thank you for your reply. That is what I also expect to get. The question is why I am not getting it?

What i am getting is (x * ScreenWidht, y * ScreenHeight, z, w).

4

Indeed. You’re confusing them because of their same order of magnitude. It seems width and height, but it is really w and w.

Try:

fixed4 col = fixed4(i.vertex.xy / i.vertex.w, 0.0, 1.0) ;
5

The SV_POSITION semantic isn’t something you would normally access in the fragment shader directly. In DX9 (and OpenGL) this will result in a shader error. However in DX11 the SV_POSITION semantic when accessed in the fragment shader is the clip position post transformation by rastorization, which is equivalent to VPOS, which is the pixel position.

If you pass the clip space position via an additional semantic, like TEXCOORD#, it’ll be as @jvo3dc described.

1 Like
6

I have tried fixed4 col = fixed4(i.vertex.xy / i.vertex.w, 0.0, 1.0) ;
However, it results in the same yellow box as in the first image.

@bgolus I am sorry I may not understand your reply. What is special about SV_POSITION? I thought it is similar to gl_FragCoord in OpenGL which gives you the current shader coordinate on the screen. Could you please help me clarify this confusion ? :slight_smile:

UPDATE:
I have tried passing another variable of type TEXCOORD1. Now everything works as expected! Thank you! (see the shader below).
Is there any good resource to figure out how Unity Semantics work?

7

SV_POSITION is the DX11 equivalent to GLSL’s gl_Position, and in most shader languages can only be accessed in the vertex shader, hence why it’ll give you an error if you try to access it in the fragment shader when using DX9 or OpenGL. However a quirk of DX11 is SV_POSITION is also accessible in the pixel (aka fragment) shader, at which point it is the equivalent of GLSL’s gl_FragCoord.

If you really do want gl_FragCood, and want it to work across multiple platforms, you have to output the vertex position as a separate variable from the v2f struct, and then add UNITY_VPOS_TYPE vpos : VPOS to your fragment shader function definition, as VPOS is the equivalent to gl_FragCoord and which Unity will properly translate for all platforms.

Btw, Unity semantics aren’t really Unity specific, they should be equivalent to DX11’s semantics. Unity will then translate them to the semantics needed by each platform. If you’re familiar with OpenGL then looking at Unity’s HLSL2GLSL might be of use to you:
https://github.com/aras-p/hlsl2glslfork

3 Likes