What could be the source of this aliasing?

Question

I am manually raytracing a 3D image. I have noticed that, the farther from the 3D image I am, the bigger the aliasing.

This 3D image is basically a voxelized representation of the stanford dragon. I have placed volume centered at the origin (the diagonals cross at (0,0,0)), meaning that one of the corners is at (-cube_dim, -cube_dim, -cube_dim) and the other is at (cube_dim, cube_dim, cube_dim).

At close range the image is fine:

(The minor "aliasing" you see here is due to me doing a ray marching algorithm, this is not the aliasing I am worried about, this was expected and acceptabel)

However if we get far away enough some aliasing starts to be seen: (This is a completely different kind of aliasing)

The fragment shader sued to generate the image is this:

#version 430

in vec2 f_coord;

out vec4 fragment_color;

uniform layout(binding=0, rgba8) image3D volume_data;

uniform vec3 camera_pos;
uniform float aspect_ratio;
uniform float cube_dim;
uniform int voxel_resolution;

#define EPSILON 0.01
// Check whether the position is inside of the specified box
bool inBoxBounds(vec3 corner, float size, vec3 position)
{
    bool inside = true;
    //Put the position in the coordinate frame of the box
    position-=corner;
    //The point is inside only if all of it's components are inside
    for(int i=0; i<3; i++)
    {
        inside = inside && (position[i] > -EPSILON);
        inside = inside && (position[i] < size+EPSILON);
    }

    return inside;
}
//Calculate the distance to the intersection to a box, or inifnity if the bos cannot be hit
float boxIntersection(vec3 origin, vec3 dir, vec3 corner0, float size)
{
    //dir = normalize(dir);
    //calculate opposite corner
    vec3 corner1 = corner0 + vec3(size,size,size);

    //Set the ray plane intersections
    float coeffs[6];
    coeffs[0] = (corner0.x - origin.x)/(dir.x);
    coeffs[1] = (corner0.y - origin.y)/(dir.y);
    coeffs[2] = (corner0.z - origin.z)/(dir.z);
    coeffs[3] = (corner1.x - origin.x)/(dir.x);
    coeffs[4] = (corner1.y - origin.y)/(dir.y);
    coeffs[5] = (corner1.z - origin.z)/(dir.z);

    float t = 1.f/0.f;
    //Check for the smallest valid intersection distance
    //We allow negative values up to -size to create correct sorting if the origin is
    //inside the box
    for(uint i=0; i<6; i++)
        t = (coeffs[i]>=0) && inBoxBounds(corner0,size,origin+dir*coeffs[i])?
            min(coeffs[i],t) : t;

    return t;
}

void main()
{
    float v_size = cube_dim/voxel_resolution;
    vec3 r = (vec3(f_coord.xy,1.f/tan(radians(40))));
    r.y /= aspect_ratio;
    vec3 dir = normalize(r);//;*v_size*0.5;
    r+= camera_pos;

    float t = boxIntersection(r, dir, -vec3(cube_dim), cube_dim*2);

    if(isinf(t))
        discard;

    if(!((r.x>=-cube_dim) && (r.x<=cube_dim) && (r.y>=-cube_dim) &&
        (r.y<=cube_dim) && (r.z>=-cube_dim) && (r.z<=cube_dim)))
    r += dir*t;

    vec4 color = vec4(0);
    int c=0;
    while((r.x>=-cube_dim) && (r.x<=cube_dim) && (r.y>=-cube_dim) &&
        (r.y<=cube_dim) && (r.z>=-cube_dim) && (r.z<=cube_dim))
    {
        r += dir*v_size*0.5;
        vec4 val = imageLoad(volume_data, ivec3(((r)*0.5/cube_dim+vec3(0.5))*(voxel_resolution-1)));

        if(val.w > 0)
        {
            color = val;
            break;
        }
        c++;
    }
    fragment_color = color;
}

Understanding the algorithm

First, we create a ray based on the screen coordiantes (we use the standard raytracing ttechnique, were the focal length is 1/tan(angle)).

We then start the ray at the camera's current position

We check intersection of the ray with the box containing our object (we basically assume that our 3D texture is a big cube in the scene and we check whether we hit it).

If we donlt hit it we discard the fragment. If we do hit it and we're outside we move along the ray until we are at the surface of the box. If we hit it and are inside we stay where we are.

At this point we are guranteed that the position of our ray is inside the box.

Now we move by small segments along the ray until we either find a non zero value or we hit the end of the box.