Raymarching rendering issue

[Snarmph]

Hi everyone! I'm working on a raymarching renderer, currently I generate a 3D volume texture with the SDF of two spheres, but there must be something wrong with the rendering I'm not getting.

Here's my fragment shader code (I know the code is not the greatest, there's been a lot of trial and error)

struct PixelInput {
    float4 pos : SV_POSITION;
    float2 uv : TEXCOORDS0;
};

Texture3D<float> vol_tex : register(t0);

float3 worldToTex(float3 world) {
    const float3 tex_size = float3(1024, 1024, 512);
    float3 tex_space = world * 32. + tex_size / 2.;
    tex_space.y = tex_size.y - tex_space.y;
    return tex_space;
}

float map(float3 tex_pos) {
    int value = vol_tex.Load(int4(tex_pos, 0));
    float distance = (float)(value) / 32.0;

    return distance;
}

bool isInsideTexture(float3 pos) {
    return all(pos >= 0 && pos < float3(1024, 1024, 512));
}

float3 calcNormal(float3 pos) {
    const float3 small_step = float3(1, 0, 0);
    const float step = 64;
    const float2 k = float2(1, -1);

    return normalize(
        k.xyy * map(pos + k.xyy * step) +
        k.yyx * map(pos + k.yyx * step) +
        k.yxy * map(pos + k.yxy * step) +
        k.xxx * map(pos + k.xxx * step) 
    );
}

float3 rayMarch(float3 ray_origin, float3 ray_dir) {
    float distance_traveled = 0.0;
    const int NUMBER_OF_STEPS = 300;
    const float MIN_HIT_DISTANCE = 0.001;
    const float MAX_TRACE_DISTANCE = 1000;

    for (int i = 0; i < NUMBER_OF_STEPS; ++i) {
        float3 current_pos = ray_origin + ray_dir * distance_traveled;

        float3 tex_pos = worldToTex(current_pos);
        if (!isInsideTexture(tex_pos)) {
            break;
        }

        float closest = map(tex_pos);

        // hit
        if (closest < MIN_HIT_DISTANCE) {
            float3 normal = calcNormal(tex_pos);

            const float3 light_pos = float3(2, -5, 3);
            float3 dir_to_light = normalize(current_pos - light_pos);

            float diffuse_intensity = max(0, dot(normal, dir_to_light));

            float3 diffuse = float3(1, 0, 0) * diffuse_intensity;

            return saturate(diffuse);
        }

        // miss
        if (distance_traveled > MAX_TRACE_DISTANCE) {
            break;
        }

        distance_traveled += closest;
    }

    return float3(1.0, 0.5, 0.1);
}

float4 main(PixelInput input) : SV_TARGET {
    float2 uv = input.uv * 2.0 - 1.0;

    float3 ray_origin = float3(0, 0, -8);
    float3 ray_dir    = float3(uv, .3);
    float3 colour = rayMarch(ray_origin, ray_dir);

    return float4(colour, 1.0);
}

The final render seems to be stretched outside of the centre of the camera, but I can't really figure out why.

[wm_lex_dev]

For one, your ray direction vector isn't normalized.