Hi all,
I have an image effect on the Post Process V2 stack that adds full-screen raymarched Perlin noise with object occlusion.
It looks and works perfectly in the scene camera, however, it is distorted in the game camera. The raymarch effects seem to move in the opposite Y-axis. The effects also seem to the visually stretched in the Y axis. If I look straight ahead and rotate left or right, everything looks fine.
Does anyone have any ideas? I’ve had to shelf this issue for a couple weeks to not lose morale, and am trying to approach it again.
Source Code:
RaymarchPostProcess.cs (PostFX V2 image effect script running in HDRP)
using System;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
[Serializable]
public sealed class ShaderParameter : ParameterOverride<Shader> { }
[Serializable]
[PostProcess(typeof(RaymarchPostProcessRenderer), PostProcessEvent.BeforeStack, "Custom/RaymarchPostProcess")]
public sealed class RaymarchPostProcess : PostProcessEffectSettings
{
public IntParameter maxIterations = new IntParameter { value = 64 };
public FloatParameter maxDistance = new FloatParameter { value = 100f };
public FloatParameter minDistance = new FloatParameter { value = 0.01f };
public DepthTextureMode GetCameraFlags()
{
return DepthTextureMode.Depth; // DepthTextureMode.DepthNormals;
}
}
public sealed class RaymarchPostProcessRenderer : PostProcessEffectRenderer<RaymarchPostProcess>
{
Transform directionalLight;
public override void Init()
{
base.Init();
GameObject light = GameObject.FindGameObjectWithTag("MainLight");
if (light)
directionalLight = light.transform;
}
public override void Render(PostProcessRenderContext context)
{
Camera _cam = context.camera;
var sheet = context.propertySheets.Get(Shader.Find("Raymarch/RaymarchHDRP"));
sheet.properties.SetMatrix("_CamFrustum", FrustumCorners(_cam));
sheet.properties.SetMatrix("_CamToWorld", _cam.cameraToWorldMatrix);
sheet.properties.SetVector("_CamWorldSpace", _cam.transform.position);
sheet.properties.SetInt("_MaxIterations", settings.maxIterations);
sheet.properties.SetFloat("_MaxDistance", settings.maxDistance);
sheet.properties.SetFloat("_MinDistance", settings.minDistance);
if (directionalLight)
{
Vector3 position = directionalLight.forward;
sheet.properties.SetVector("_LightDir", new Vector4(position.x, position.y, position.z, 1));
}
context.command.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
}
private Matrix4x4 FrustumCorners(Camera cam)
{
Transform camtr = cam.transform;
Vector3[] frustumCorners = new Vector3[4];
cam.CalculateFrustumCorners(new Rect(0, 0, 1, 1),
cam.farClipPlane, cam.stereoActiveEye, frustumCorners);
Vector3 bottomLeft = camtr.TransformVector(frustumCorners[1]);
Vector3 topLeft = camtr.TransformVector(frustumCorners[0]);
Vector3 bottomRight = camtr.TransformVector(frustumCorners[2]);
Matrix4x4 frustumVectorsArray = Matrix4x4.identity;
frustumVectorsArray.SetRow(0, bottomLeft);
frustumVectorsArray.SetRow(1, bottomLeft + (bottomRight - bottomLeft) * 2);
frustumVectorsArray.SetRow(2, bottomLeft + (topLeft - bottomLeft) * 2);
return frustumVectorsArray;
}
}
RaymarchHDRP.shader
Shader "Raymarch/RaymarchHDRP"
{
SubShader
{
Cull Off ZWrite Off ZTest Always
Pass
{
HLSLPROGRAM
#pragma target 3.5
#pragma vertex vert
#pragma fragment frag
//#include "Packages/com.unity.postprocessing/PostProcessing/Shaders/StdLib.hlsl"
//#include "HLSLSupport.cginc"
#include "UnityCG.cginc"
//TEXTURE2D_SAMPLER2D(_MainTex, sampler_MainTex);
uniform sampler2D _MainTex;
uniform sampler2D_float _CameraDepthTexture, sampler_CameraDepthTexture;
half4 _MainTex_ST;
uniform float4 _CamWorldSpace;
uniform float4x4 _CamFrustum, _CamToWorld;
uniform int _MaxIterations;
uniform float _MaxDistance;
uniform float _MinDistance;
uniform float3 _LightDir;
float4 _Tint;
uniform float4 _MainTex_TexelSize;
struct AttributesDefault
{
float3 vertex : POSITION;
half2 texcoord : TEXCOORD0;
};
struct v2f
{
float4 vertex : SV_POSITION;
float2 texcoord : TEXCOORD0;
float2 texcoordStereo : TEXCOORD1;
float4 ray : TEXCOORD2;
};
// Vertex manipulation
float2 TransformTriangleVertexToUV(float2 vertex)
{
float2 uv = (vertex + 1.0) * 0.5;
return uv;
}
v2f vert(AttributesDefault v )
{
v2f o;
v.vertex.z = 0.1;
o.vertex = float4(v.vertex.xy, 0.0, 1.0);
o.texcoord = TransformTriangleVertexToUV(v.vertex.xy);
o.texcoordStereo = TransformStereoScreenSpaceTex(o.texcoord, 1.0);
int index = (o.texcoord.x / 2) + o.texcoord.y;
o.ray = _CamFrustum[index];
return o;
}
float sdSphere(float3 position, float3 origin, float radius)
{
return distance(position, origin) - radius;
}
float distanceField(float3 p) {
return sdSphere(p, float3(1, 0, 0), 2);
}
float3 getNormal(float3 p)
{
const float2 offset = float2(0.001, 0.0);
float3 n = float3(
distanceField(p + offset.xyy) - distanceField(p - offset.xyy),
distanceField(p + offset.yxy) - distanceField(p - offset.yxy),
distanceField(p + offset.yyx) - distanceField(p - offset.yyx));
return normalize(n);
}
fixed4 raymarching(float3 rayOrigin, float3 rayDirection, float depth) {
fixed4 result = float4(1, 1, 1, 1);
float t = 0.01; // Distance Traveled from ray origin (ro) along the ray direction (rd)
for (int i = 0; i < _MaxIterations; i++)
{
if (t > _MaxDistance || t >= depth)
{
result = float4(rayDirection, 0); // color backround from ray direction for debugging
break;
}
float3 p = rayOrigin + rayDirection * t; // This is our current position
float d = distanceField(p); // should be a sphere at (0, 0, 0) with a radius of 1
if (d <= _MinDistance) // We have hit something
{
// shading
float3 n = getNormal(p);
float light = dot(-_LightDir, n);
result = float4(fixed3(1, 1, 1) * light, 1); // yellow sphere should be drawn at (0, 0, 0)
break;
}
t += d;
}
return result;
}
float4 frag(v2f i) : SV_Target
{
i.texcoord.y = 1 - i.texcoord.y;
float4 col = tex2D(_MainTex, i.texcoord);
float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, UnityStereoTransformScreenSpaceTex(i.texcoord));
depth = Linear01Depth(depth);
depth *= length(i.ray);
float3 rayOrigin = _CamWorldSpace;
float3 rayDirection = normalize(i.ray);
float4 result = raymarching(rayOrigin, rayDirection, depth);
return fixed4(col * (1.0 - result.w) + result.xyz * result.w, 1.0);
}
ENDHLSL
}
}
}
Here is an image of the scene and game camera in the same position and orientation.
