Pixel ray direction in frag shader

Unity Engine
,
1

Hey Unity Peoples,

This is my first post and I have about 2 months working with Unity at this point. I really think this is a simple problem and I was hoping I could ask the experts. I have no doubt I am doing something really dumb.

What I am trying to do is run a pseudo “ray marching” algorithm on top of my existing game. This way I can do fog, glass coloration, lighting and some other volumetric effects. I am using an image effect shader on a camera because this will basically go over the screen and fill in the spaces I want with the fog etc. The only problem is I can’t get the angle of a ray from each pixel correct.

I have gone through several awesome tutorials (Like this one) and was able to get one working but the way it worked was by placing a quad in front of the camera. This of course obstructed the rest of the game lol. Others were unlit shaders on objects not on the camera so also not what I’m looking for. All I want is to have a float3 with the direction of the ray from that pixel in my fragment shader. Obviously in world space corrected for camera rotation etc. I think I can do the rest of my trig from there. Here is what I have…

HLSL

Shader "RayShader/RayShader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //_CamAng;
        //_FOV;
        //_FOVXAng;
        //_FOVYAng;
    }
    SubShader
    {
        // No culling or depth
        Cull Off ZWrite Off ZTest Always

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            sampler2D _MainTex;

            uniform float3 _CamAng;
            uniform float3 _FOV;
            uniform float2 _FOVXAng;
            uniform float2 _FOVYAng;

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);

                float3 WorldSpaceDirection = 0;//This is where i want the angle of a ray from this pixel in world space!

                col = 0.5;
                float PixXAng = lerp(_FOVYAng.y, _FOVYAng.x, i.uv.x);//This is junk.
                float PixYAng = lerp(_FOVXAng.y, _FOVXAng.x, i.uv.y);//Im just grasping at straws at this point.
                PixXAng = (sin(PixXAng) * 0.5) + 0.5;
                PixYAng = (sin(PixYAng) * 0.5) + 0.5;

                col *= fixed4(PixXAng, PixYAng,0, 0);
                return col;
            }
            ENDCG
        }
    }
}

C#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[ExecuteInEditMode]
public class CamToShader : MonoBehaviour
{
  public Material MyMat;
  public Shader MyShade;
  public Camera MyCamera;

  private Vector3 _CamAng;
  private Vector3 _FOV;
  private Vector2 _FOVXAng;
  private Vector2 _FOVYAng;

  private Vector2 Flip = new Vector2(-1, 1);
  private Vector2 TempAng;

  void OnRenderImage(RenderTexture source, RenderTexture destination)
  {
    if (!MyMat)
    {
      Graphics.Blit(source, destination);
      return;
    }
    else
    {
      _CamAng = Mathf.Deg2Rad * MyCamera.transform.eulerAngles;
      _FOV.y = Mathf.Deg2Rad * MyCamera.fieldOfView * 0.5f;
      _FOV.x = _FOV.y * MyCamera.aspect;

      _FOVXAng = new Vector2(-_FOV.x, _FOV.x);
      _FOVXAng += new Vector2(_CamAng.x, _CamAng.x);

      _FOVYAng = new Vector2(-_FOV.y, _FOV.y);
      _FOVYAng += new Vector2(_CamAng.y, _CamAng.y);

      MyMat.SetVector("_CamAng", _CamAng);
      MyMat.SetVector("_FOV", _FOV);
      MyMat.SetVector("_FOVXAng", _FOVXAng);
      MyMat.SetVector("_FOVYAng", _FOVYAng);

      Graphics.Blit(source, destination, MyMat);
      return;
    }
  }
}

I was very excited when I got this together because at first the colors on the screen tracked with the camera rotation but if I rotate beyond straight up the colors flip and camera rotation on z does nothing. Is there a built in shaderlab variable that has the vector of each frag?

Anything will help thanks in advance. I’ve got to head to bed for work but I appreciate any help and will check in tomorrow.

2

I guess that was a dumb question. No problem, for the next person I was expecting to get Euler angles and then convert them to vectors but that was a mess (math vectors not datatype). I ended up just getting 4 vectors from the frustum and then I passed them to the shader like this.

    Vector3[] FrustumCorners = new Vector3[4];
    Vector3[] NormCorners = new Vector3[4];
   
    MyCam.CalculateFrustumCorners(new Rect(0, 0, 1, 1), MyCam.farClipPlane, Camera.MonoOrStereoscopicEye.Mono, FrustumCorners);
    for (int i = 0; i < 4; i++)
    {
      NormCorners[i] = MyCam.transform.TransformVector(FrustumCorners[i]);
      NormCorners[i] = NormCorners[i].normalized;
    }
    Debug.DrawRay(new Vector3(0, 0, 0), NormCorners[0], Color.red);   //BL
    Debug.DrawRay(new Vector3(0, 0, 0), NormCorners[1], Color.blue);  //TL
    Debug.DrawRay(new Vector3(0, 0, 0), NormCorners[2], Color.yellow);//TR
    Debug.DrawRay(new Vector3(0, 0, 0), NormCorners[3], Color.green); //BR
    MyMaterial.SetVector("_BL", NormCorners[0]);
    MyMaterial.SetVector("_TL", NormCorners[1]);
    MyMaterial.SetVector("_TR", NormCorners[2]);
    MyMaterial.SetVector("_BR", NormCorners[3]);

Then in the shader I do a lerp on the vectors like an H and normalize like this.

            float4 _BL;
            float4 _TL;
            float4 _TR;
            float4 _BR;

            float4 NormalLeft;
            float4 NormalRight;
            float4 NormalH;


            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                NormalLeft = lerp(_BL, _TL,i.uv.y);
                NormalRight = lerp(_BR, _TR, i.uv.y);
                NormalH = lerp(NormalLeft, NormalRight,i.uv.x);
                NormalH = normalize(NormalH);

Then I just add the camera position to that and I have a vector. Stepping from camera position along this vector produced what looks like correct results. ie

SamplePoint += CamPos + (NormalH *1)
SamplePoint += CamPos + (NormalH *2)
SamplePoint += CamPos + (NormalH *3)

I’m sure there are better ways but this is fast cheap and all I needed. Seems to work with FOV changes and any rotation x,y or z. Thanks.

3 Likes
3

This was not a dumb question. I am looking for the exact same thing. Although I feel like there should be an easier way to do this directly in the shader.

4

Hi, I think you are looking for view direction.

If you are using shader graph, you can use the view direction node (not view vector node) directly.

For custom shaders, it’s normalize(camera position - vertex or pixel’s position).

The global variable “_WorldSpaceCameraPos” contains the camera’s positionWS. (see documentation)

5

Wow, once again @wwWwwwW1 you have come to my rescue.

I am so bad at shaders I had to learn the simplest stuff just to get this working.

I had to add this line in the vert method

result.worldSpacePos = mul(unity_ObjectToWorld, input.positionOS).xyz;

which adds a world space to each fragment (I think).

And then added this to the frag shader

float3 direction = normalize(input.worldSpacePos.xyz - _WorldSpaceCameraPos);
1 Like