To demonstrate that this works, I built a test scene in Unity that would render a series of cubes with the standard rasterization pipeline, then also fire ways and overlay a greyscale version calculated raycasting-style. You can see from this cross-fade between the two, the raycasting approach accurately reproduces the same linear perspective, with no erroneous curving of the walls:

To demonstrate that this works, I built a test scene in Unity that would render a series of cubes with the standard rasterization pipeline, then also fire rays and overlay a greyscale version calculated raycasting-style. You can see from this cross-fade between the two, the raycasting approach accurately reproduces the same linear perspective, with no erroneous curving of the walls:

offset = ((i * 2.0 / WIDTH_MM) - 1.0) * halfWidth;

rayDirection.x = forward.x + offset * right.x;
rayDirection.y = forward.y + offset * right.y;

You can optionally normalize or scale this direction vector as needed to suit your ray intersection routines.

offset = ((i * 2.0 / (WIDTH_MM - 1.0)) - 1.0) * halfWidth;

rayDirection.x = forward.x + offset * right.x;
rayDirection.y = forward.y + offset * right.y;

You can optionally normalize or scale this direction vector as needed to suit your ray intersection routines.

To demonstrate that this works, I built a test scene in Unity that would render a series of cubes with the standard rasterization pipeline, then also fire ways and overlay a greyscale version calculated raycasting-style. You can see from this cross-fade between the two, the raycasting approach accurately reproduces the same linear perspective, with no erroneous curving of the walls:

Here's the code I use to fire my rays, and save the depths into a buffer to use in drawing the raycast version:

void Update()
{
    // Compute worldspace width of the projection plane (at a depth of 1)
    // using the camera's field of view (which in Unity is a vertical FoV).
    float halfHeight = Mathf.Tan(_camera.fieldOfView * Mathf.Deg2Rad / 2.0f);
    float halfWidth = _camera.aspect * halfHeight;   

    // For each pixel column in our raycasting buffer...
    for(int i = 0; i < _depths.Length; i++) {
        // Compute a ray firing through that point on the image plane.
        float offset = (2.0f * i) / (_depths.Length - 1.0f) - 1.0f;
        var ray = new Ray(
            transform.position, 
            transform.forward + transform.right * halfWidth * offset
        );

        // If it hits something, get its depth along the camera forward vector.
        RaycastHit hit;
        float depth = float.PositiveInfinity;
        if(Physics.Raycast(ray, out hit)) {
            depth = Vector3.Dot(hit.point - transform.position, transform.forward);                
        }
        _depths[i] = new Color(depth, depth, depth, depth);
    }

    _depthRibbon.SetPixels(_depths);
    _depthRibbon.Apply(false, false);
}

And inside the shader:

fixed4 frag (v2f i) : SV_Target
{
    // Sample depth from the buffer populated by our rays.
    float depth = tex2D(_MainTex, i.uv).r;

    // Wall height is our master height divided by depth.       
    float height = _WallScale / depth;

    // Default floor / ceiling to black.
    fixed4 col = fixed4(0, 0, 0, _Alpha);

    // If the pixel we're shading is closer to the middle of the screen
    // than the edge of the wall, shade it as a wall.
    if (abs(i.uv.y - 0.5f) < height) {
        col = lerp(fixed4(0, 0, 0, _Alpha), fixed4(1, 1, 1, _Alpha), exp(-depth * 0.3f + 0.3f));
    }
    
    return col;
}