trouble getting ray direction for voxel raymarcher

[sterile ridge]

So i am aware there is already a lot of info on this topic but i am having trouble putting the theory into actual code.

I am making a raymarcher to march into an octree and get the color of the voxel the ray hits.
But i am having trouble getting the direction of the ray. I saw this https://computergraphics.stackexchange.com/questions/8479/how-to-calculate-ray but i dont understand how the code works.
im working with bevy on the cpu side, so using wgsl in gpu land.

this is my direction code now but it does not take into account where the camera is facing

fn ray_dir(x: f32, y: f32) -> vec3<f32> {
    let d = 1/tan(radians(screen.fov/2));
    let px = x + 0.5;
    let py = y + 0.5;
    let aspect_ratio = f32(screen.width) / f32(screen.height);

    let ray_dir_x = aspect_ratio * (2 * px / f32(screen.width)) - 1;
    let ray_dir_y = (2 * py/f32(screen.height)) - 1;
    let ray_dir_z = d;

    return vec3<f32>(ray_dir_x, ray_dir_y, ray_dir_z);
}

this makes the screen either full background or full voxel(all voxels are the same colour as of now)

so my Question is how do i get the direction of the ray for each pixel in wgsl?

[sterile ridge]

--edit--

i have used the same code in bevy to debug where the rays go:

for x in 0..shader_screen.width / 100 {
        for y in 0..shader_screen.height / 100 {
            let y = y * 100;
            let x = x * 100;
            let ray_dir = ray_dir(x as f32, y as f32, shader_screen.clone());
            gizmos.ray(
                Vec3 {
                    x: 0.0,
                    y: 0.0,
                    z: 0.0,
                },
                ray_dir,
                Color::RED,
            );
        }
    }

fn ray_dir(x: f32, y: f32, screen: ShaderScreen) -> Vec3 {
    let d = 1.0 / ((screen.fov / 2.0).to_radians()).tan();
    let px = x + 0.5;
    let py = y + 0.5;
    let aspect_ratio = screen.width as f32 / screen.height as f32;

    let dir_x = aspect_ratio * (2.0 * px / screen.width as f32) - 1.0;
    let dir_y = (2.0 * py / screen.height as f32) - 1.0;
    let dir_z = d;

    let mut vector = Vec3 {
        x: dir_x.abs(),
        y: dir_y.abs(),
        z: dir_z as f32,
    };
    vector = vector.normalize();

    vector = Vec3 {
        x: vector.x * 15.0,
        y: vector.y * 15.0,
        z: vector.z * 15.0,
    };

    return vector;
}

and this would look like this: https://imgur.com/Gulniva
all seem to go in the same spot on the bottom left. But there is also a dot/line seen more towards the middle of the camera. that dot moves with the camera for some odd reason.

after some further inspection it seems the rays go in different directions but the difference is very small

i changed 1.0 / ((screen.fov / 2.0).to_radians()).tan();
to 1.0 / ((screen.fov / 2.0)).tan();
and now i get this:

wich is a lot better lol

[sterile ridge]

in bevy i can use this

fn ray_dir_v3(x: f32, y: f32, camera: (&GlobalTransform, &Transform, &Camera)) -> Vec3 {
    let ndc_x = (x + 0.5) / RESWIDTH as f32;
    let ndc_y = (y + 0.5) / RESHIGHT as f32;
    let world_pos = camera
        .2
        .ndc_to_world(camera.0, Vec3::new(ndc_x, ndc_y, 0.1))
        .unwrap();
    let mut dir = (world_pos - camera.0.translation()).normalize();

    dir = Vec3::new(dir.x * 50.0, dir.y * 50.0, dir.z * 50.0);

    dir
}

to get this result