bool AABBIntersect(float* mina,  // min vector of boxa

                   float* maxa,  // max vector of boxa 

                   float* minb,  // min vector of boxb

                   float* maxb,  // max vector of boxb

                   float* ncoll,       // normal of collision.

                   float* dcoll)          // face intersected.

{

    // the normal of each face.

    static const float faces[6][3] = 

    { 

        {-1,  0,  0}, // 'left' face normal (-x direction)

        {1,  0,  0}, // 'right' face normal (+x direction)

        {0, -1,  0}, // 'bottom' face normal (-y direction)

        {0,  1,  0}, // 'top' face normal (+y direction)

        {0,  0, -1}, // 'far' face normal (-z direction)

        {0,  0,  1}, // 'near' face normal (+x direction)

    };

    

    // distance of collided box to the face.

    float distances[6] = 

    { 

        (maxb[0] - mina[0]), // distance of box 'b' to face on 'left' side of 'a'.

        (maxa[0] - minb[0]), // distance of box 'b' to face on 'right' side of 'a'.

        (maxb[1] - mina[1]), // distance of box 'b' to face on 'bottom' side of 'a'.

        (maxa[1] - minb[1]), // distance of box 'b' to face on 'top' side of 'a'.

        (maxb[2] - mina[2]), // distance of box 'b' to face on 'far' side of 'a'.

       (maxa[2] - minb[2]) // distance of box 'b' to face on 'near' side of 'a'.
}
     ;



    // scan each face, make sure the box intersects,

    // and take the face with least amount of intersection

    // as the collided face.

    for(int i = 0; i < 6; i ++)

    {

        // box does not intersect face. So boxes don't intersect at all.

        if(distances[i] < 0.0f) 

            return false;



        // face of least intersection depth. That's our candidate.

        if((i == 0) || (distances[i] < *dcoll)) 

        {

            ncoll[0] = faces[i][0];
            ncoll[1] = faces[i][1];
            ncoll[2] = faces[i][2];

            *dcoll = distances[i];

        }        

    }

    return true;

}

Checking for collision is like:

float mina[3] = {acenter[0]-ax_length/2, acenter[1]-ay_length/2, acenter[2]-az_length/2};
float maxa[3] = {acenter[0]+ax_length/2, acenter[1]+ay_length/2, acenter[2]+az_length/2};
float minb[3] = {bcenter[0]-bx_length/2, bcenter[1]-by_length/2, bcenter[2]-bz_length/2};
float maxb[3] = {bcenter[0]+bx_length/2, bcenter[1]+by_length/2, bcenter[2]+bz_length/2};
float Norm[3];
float dist;

AABBIntersect( minb, maxb, mina, maxa, Norm, &dist )

ax_center += Norm[0] * -dist, ay_center += Norm[1] * -dist, az_center += Norm[2] * -dist;