Raymarching orthographic view

Question

I need to calculate ray origin and ray direction vector for ray-marching orthographic view.

I know that ray origin must move for each pixel and not stay from center and I believe this formula ro = ro + vec3(v_UV * orthRectSize, 0.); should work.

I don't know how to calculate ray direction.

I managed to get it to work by making rd = vec3(0, 0, 1) and then rotating world content. Is there better method to calculate correct values directly?

Answer 1

A more general way to get the ray origin and ray direction would be to reconstruct the fragment's location on both the near and far plane of the view frustum in world coordinates, and then find the direction from the fragment on the near plane to the fragment on the far plane.

First you need to convert the fragment (image x,y) to normalized device coordinates. The operation would change depending on the layout of pixels in your graphics library but generally it would look something like this Rust function:

/// Converts a fragment from screen space to a normalized device space.
///
/// See [WGPU's docs on clip space](https://www.w3.org/TR/webgpu/#primitive-clipping).
///
/// ### tl;dr
/// - x: find `frag.x` where `[-1.0 (left), 1.0 (right)]`
/// - y: find `frag.y` where `[-1.0 (bottom), 1.0 (top)]`
/// - z: `frag.z`, where `[0.0, 1.0]` (which is near depends on the projection)
fn frag_coord_to_ndc(frag_coord: Vec3, screen_resolution: Vec2) -> Vec3 {
    let invert_y = Vec2::new(1.0, -1.0); // my frag coords increase in y downwards
    ((2.0 * frag_coord.xy() / screen_resolution - 1.0) * invert_y).extend(frag_coord.z)
}

Then you convert the fragment's position from normalized device coordinates to world coordinates by setting the position's w component to 1.0 and multiplying by the inverse of the projection * view matrix, followed by dividing the resulting point by it's w component:

fn ndc_coord_to_world(clip_coord: Vec3, camera: &Camera) -> Vec3 {
    let p = (camera.projection * camera.view).inverse() * clip_coord.extend(1.0);
    p.xyz() / p.w
}

Put those operations together to convert from a fragment to world space:

/// Convert the fragment coordinate to world space.
fn frag_coord_to_world(frag_coord: Vec3, screen_resolution: Vec2, camera: &Camera) -> Vec3 {
    // Convert fragment coordinates to clip
    let clip_coord = frag_coord_to_ndc(frag_coord, screen_resolution);
    // Transform point to world space
    let world_point = ndc_coord_to_world(clip_coord.xyz(), camera);
    world_point.xyz()
}

Now calculate the fragment position on the near plane (z = 0.0 in my graphics library) and the far plane (z = 1.0). Subtract the far point from the near point, normalize it, and now you have your ray direction. The ray origin is the fragment's point on the near plane:

fn find_ray_through_world_frustum(
    frag_coord: Vec2,
    resolution: Vec2,
    camera: &Camera,
) -> Ray {
    let frustum_near = frag_coord_to_world(frag_coord.extend(0.0), resolution, camera);
    let frustum_far = frag_coord_to_world(frag_coord.extend(1.0), resolution, camera);
    let vector = frustum_far - frustum_near;
    let direction = vector.normalize();
    Ray {
        origin: frustum_near,
        direction,
    }
}

I hope that helps!