Having trouble converting a world space position to screen space in a shader

Unity Engine
,
1

Hi, I am having trouble converting a 3d world position to a 2d screen position.
I"ve been at it for a while, trying every code snipped I could find but the results are always wrong.
Iam trying to do a simple example where a point in world space is rendered as a red circle on screen from any view angle.

            HLSLPROGRAM
            half4 frag(Varyings IN) : SV_TARGET
            {

               
               float3 wpos = float3(0,0,4);    

               float4 cpos = mul(UNITY_MATRIX_VP, float4(wpos.xyz, 1.0));
               float4 spos = ComputeScreenPos(cpos);
               spos.xy /= spos.w;


               if (distance(IN.uv, spos.xy) < 0.05)
                   return float4(1,0,0,0);
              
               float4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_point_clamp, IN.uv);
             
               return tex;
            }
            ENDHLSL

I’ve tried this:

and this:

and this:

and this:

but the results are always wrong. Either the sphere is not moving at all, or it’s not on the target.
What am I doing wrong?

Iam using URP btw, if it makes a difference.

2

What are you trying to make?

3

So, you need to understand what this matrix is.

This transforms from the current world position to the clip space position … for the geometry that is currently being rendered. The fact you’re comparing the calculated screen position to the uv makes me believe this is being done for a post process effect. When rendering a post process, the geometry that’s being rendered is a single quad or triangle that’s covering the entire screen. The easiest way to do that is by having the “world” be the camera plane, and thus the “world to clip space” matrix is essentially empty. It is not the world space of the scene anymore. So you can’t use it to get a clip space position of something in the game scene.

For that you need to use the unity_WorldToCamera and unity_CameraProjection matrices. Check the above links you posted for examples that use those specifically.

4

Thanks, yes I forgot to mention that I am indeed trying to work with post processing.
I’ve tried the snipped in the first link before and this is the result I am getting:

https://imgur.com/yLnVDqL

            HLSLPROGRAM
            half4 frag(Varyings IN) : SV_TARGET
            {

               float3 wpos = float3(0,0,4);    
               wpos = normalize(wpos - _WorldSpaceCameraPos) * (_ProjectionParams.y + (_ProjectionParams.z - _ProjectionParams.y)) + _WorldSpaceCameraPos;

               float2 res = float2(0,0);
               float3 cpos = mul(unity_WorldToCamera, wpos);
               float camPosZ = cpos.z;
               float height = 2 * camPosZ / unity_CameraProjection._m11;
               float width = _ScreenParams.x / _ScreenParams.y * height;
               res.x = (cpos.x + width / 2) / width;
               res.y = (cpos.y + height / 2) / height;


               if (distance(IN.uv, res.xy) < 0.05 )
                   return float4(1,0,0,0);
              
               float4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_point_clamp, IN.uv);
             
               return tex;
            }
            ENDHLSL

It works, but there is an issue with it where it also draws an inverted positioned circle when I turn around and look away from the stated world position.

The other issue with it is that I have no idea why it works or what it does.
Why does the wpos need to be processed first?
Why does it need that unity*_CameraProjection._m11* single matrix value?
What are those height, width, divide by 2 transformations?

5

To answer some of these questions, I’m going to start by correcting / simplifying a few things in the above code:

float4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_point_clamp, IN.uv);

float3 circle_worldPos = float3(0,0,4);
// this avoids the extra line of code to subtract the world space camera position
float4 circle_cameraPos = mul(unity_WorldToCamera, float4(circle_worldPos, 1.0));

// if behind the camera, ignore
if (circle_cameraPos.z <= 0.0)
  return tex;

// the WorldToCamera matrix is +z forwad, but the projection matrix expects a -z forward view space
circle_cameraPos.z = -circle_cameraPos.z;

// transform view space to clip space position
float4 circle_clipPos = mul(unity_CameraProjection, circle_cameraPos);

// clip space has a -w to +w range for on screen elements, so divide x and y by w to get a -1 to +1 range
// then multiply by 0.5 and 0.5 to bring from a -1 to +1 range to 0.0 to 1.0 screen position UV
float2 circle_screenPos = (circle_clipPos.xy / circle_clipPos.w) * 0.5 + 0.5;

// offset between the circle center and the screen position
float2 circle_screenOffset = IN.uv - circle_screenPos;

// get the aspect ratio of the screen and adjust the x axis of the offset so you get a circle instead of an oval
float aspect = _ScreenParams.x/_ScreenParams.y;
circle_screenOffset.x *= aspect;

float dist_to_circle = length(circle_screenOffset);

if (dist_to_circle < 0.05)
  return float4(1,0,0,0);

return tex;
6

Most of the code you used was trying to account for a few mistakes they made. Like they used a float3 in the mul with unity_WorldToCamera, which only applies the rotation from that matrix. You need to use a float4 with a w of 1.0 for it to apply the transform too. And then they are taking a camera space position (which is a position relative to the camera, like if you move an object to be a child of the Camera game object) and then are using the camera space depth (cpos.z), the projection’s FOV (unity_CameraProjection._m11), and the screen’s aspect ratio to try and rescale that camera space position back into screen space. And it all kind of works, but is just way more complicated than it needed to be.

7

Thank you very much for the explanation.

btw, at line 28. it should be length(circle_screenOffset)

8

yarp

I just typed that out, didn’t test it, so there absolutely could be bugs.:smile: