splink/source/language_layer.c

// NOTE(allen): Things I added durring this jam
// Inf32
// NegInf32
// AbsoluteValue
// StringSkip
// StringChop
// "strings.c"
// RangeuContains
// RangeSplit
// bug in RectContains
// bug in RectOverlaps
// StringMatchFlag_MatchCase -> StringMatchFlag_CaseInsensitive
// bug in StringListJoin
// fleshed out Length/Norm types for vectors
// TODO(allen): change the other scalar functions
// StringSplit
// S8Range
// f32Round

////////////////////////////////
// NOTE(allen): Scalar

#define FMod fmodf
#define SquareRoot sqrtf
#define Sin sinf
#define Cos cosf
#define Tan tanf
#define Pow32 powf

internal i32
i32Ceil(f32 x)
{
    if (x > 0)
    {
        return(((i32) x) + 1);
    }
    else
    {
        return(((i32) x));
    }
}

internal i32
i32Floor(f32 x)
{
    if (x > 0)
    {
        return(((i32) x));
    }
    else
    {
        return(((i32) x) - 1);
    }
}

internal f32
f32Ceil(f32 x)
{
    if (x > 0)
    {
        return((f32) ((i32) x) + 1);
    }
    else
    {
        return((f32) ((i32) x));
    }
}

internal f32
f32Floor(f32 x)
{
    if (x > 0)
    {
        return((f32) ((i32) x));
    }
    else
    {
        return((f32) ((i32) x) - 1);
    }
}

internal f32
f32Round(f32 x)
{
    return(f32Floor(x + 0.5f));
}

internal f32
Lerp(f32 a, f32 t, f32 b)
{
    return(a + (b - a)*t);
}

internal f32
AbsoluteValue(f32 f){
    union { u32 u; f32 f; } x;
    x.f = f;
    x.u &= ~Sign32;
    return(x.f);
}

internal f32
Inf32(void){
    union { u32 u; f32 f; } x;
    x.u = Exponent32;
    return(x.f);
}

internal f32
NegInf32(void){
    union { u32 u; f32 f; } x;
    x.u = Sign32 | Exponent32;
    return(x.f);
}

internal f32
SignOfSide(Side side){
    return((side == Side_Min)?-1.f:1.f);
}

////////////////////////////////
// NOTE(allen): vector

#define V2Expand(v) ((v).x), ((v).y)
#define V3Expand(v) ((v).x), ((v).y), ((v).z)
#define V4Expand(v) ((v).x), ((v).y), ((v).z), ((v).w)

internal v2
V2Add(v2 a, v2 b)
{
    v2 c = { a.x + b.x, a.y + b.y };
    return c;
}
internal v3
V3Add(v3 a, v3 b)
{
    v3 c = { a.x + b.x, a.y + b.y, a.z + b.z };
    return c;
}
internal v4
V4Add(v4 a, v4 b)
{
    v4 c = { a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w };
    return c;
}

internal v2
V2Sub(v2 a, v2 b)
{
    v2 c = { a.x - b.x, a.y - b.y };
    return c;
}
internal v3
V3Sub(v3 a, v3 b)
{
    v3 c = { a.x - b.x, a.y - b.y, a.z - b.z };
    return c;
}
internal v4
V4Sub(v4 a, v4 b)
{
    v4 c = { a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w };
    return c;
}

internal v2
V2Mul(v2 v, f32 f)
{
    v.x *= f;
    v.y *= f;
    return v;
}
internal v3
V3Mul(v3 v, f32 f)
{
    v.x *= f;
    v.y *= f;
    v.z *= f;
    return v;
}
internal v4
V4Mul(v4 v, f32 f)
{
    v.x *= f;
    v.y *= f;
    v.z *= f;
    v.w *= f;
    return v;
}

internal f32
V2Dot(v2 a, v2 b)
{
    return a.x*b.x + a.y*b.y;
}
internal f32
V3Dot(v3 a, v3 b)
{
    return a.x*b.x + a.y*b.y + a.z*b.z;
}
internal f32
V4Dot(v4 a, v4 b)
{
    return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
}

internal v2
V2Hadamard(v2 a, v2 b)
{
    v2 v = {a.x*b.x, a.y*b.y};
    return(v);
}
internal v3
V3Hadamard(v3 a, v3 b)
{
    v3 v = {a.x*b.x, a.y*b.y, a.z*b.z};
    return(v);
}
internal v4
V4Hadamard(v4 a, v4 b)
{
    v4 v = {a.x*b.x, a.y*b.y, a.z*b.z, a.w*b.w};
    return(v);
}

internal f32
V2Length1(v2 a)
{
    return(AbsoluteValue(a.x) + AbsoluteValue(a.y));
}
internal f32
V3Length1(v3 a)
{
    return(AbsoluteValue(a.x) + AbsoluteValue(a.y) + AbsoluteValue(a.z));
}
internal f32
V4Length1(v4 a)
{
    return(AbsoluteValue(a.x) + AbsoluteValue(a.y) + AbsoluteValue(a.z) + AbsoluteValue(a.w));
}

internal f32
V2Length2(v2 a)
{
    return SquareRoot(V2Dot(a,a));
}
internal f32
V3Length2(v3 a)
{
    return SquareRoot(V3Dot(a,a));
}
internal f32
V4Length2(v4 a)
{
    return SquareRoot(V4Dot(a,a));
}

#define V2Length V2Length2
#define V3Length V3Length2
#define V4Length V4Length2

internal f32
V2LengthInf(v2 a)
{
    f32 f1 = AbsoluteValue(a.x);
    f32 f2 = AbsoluteValue(a.y);
    f1 = Max(f1, f2);
    return(f1);
}
internal f32
V3LengthInf(v3 a)
{
    f32 f1 = AbsoluteValue(a.x);
    f32 f2 = AbsoluteValue(a.y);
    f32 f3 = AbsoluteValue(a.z);
    f1 = Max(f1, f2);
    f1 = Max(f1, f3);
    return(f1);
}
internal f32
V4LengthInf(v4 a)
{
    f32 f1 = AbsoluteValue(a.x);
    f32 f2 = AbsoluteValue(a.y);
    f32 f3 = AbsoluteValue(a.z);
    f32 f4 = AbsoluteValue(a.w);
    f1 = Max(f1, f2);
    f1 = Max(f1, f3);
    f1 = Max(f1, f4);
    return(f1);
}

#define V2Max V2LengthInf
#define V3Max V3LengthInf
#define V4Max V4LengthInf

internal f32
V2Min(v2 a)
{
    f32 f1 = AbsoluteValue(a.x);
    f32 f2 = AbsoluteValue(a.y);
    f1 = Min(f1, f2);
    return(f1);
}
internal f32
V3Min(v3 a)
{
    f32 f1 = AbsoluteValue(a.x);
    f32 f2 = AbsoluteValue(a.y);
    f32 f3 = AbsoluteValue(a.z);
    f1 = Min(f1, f2);
    f1 = Min(f1, f3);
    return(f1);
}
internal f32
V4Min(v4 a)
{
    f32 f1 = AbsoluteValue(a.x);
    f32 f2 = AbsoluteValue(a.y);
    f32 f3 = AbsoluteValue(a.z);
    f32 f4 = AbsoluteValue(a.w);
    f1 = Min(f1, f2);
    f1 = Min(f1, f3);
    f1 = Min(f1, f4);
    return(f1);
}

internal v2
V2Norm1(v2 v)
{
    f32 inv_length = 1.f/V2Length1(v);
    v2 result = { v.x*inv_length, v.y*inv_length, };
    return result;
}
internal v3
V3Norm1(v3 v)
{
    f32 inv_length = 1.f/V3Length1(v);
    v3 result = { v.x*inv_length, v.y*inv_length, v.z*inv_length, };
    return result;
}
internal v4
V4Norm1(v4 v)
{
    f32 inv_length = 1.f/V4Length1(v);
    v4 result = { v.x*inv_length, v.y*inv_length, v.z*inv_length, v.w*inv_length, };
    return result;
}

internal v2
V2Norm2(v2 v)
{
    f32 inv_length = 1.f/V2Length2(v);
    v2 result = { v.x*inv_length, v.y*inv_length, };
    return result;
}
internal v3
V3Norm2(v3 v)
{
    f32 inv_length = 1.f/V3Length2(v);
    v3 result = { v.x*inv_length, v.y*inv_length, v.z*inv_length, };
    return result;
}
internal v4
V4Norm2(v4 v)
{
    f32 inv_length = 1.f/V4Length2(v);
    v4 result = { v.x*inv_length, v.y*inv_length, v.z*inv_length, v.w*inv_length, };
    return result;
}

#define V2Normalize V2Norm2
#define V3Normalize V3Norm2
#define V4Normalize V4Norm2

internal v2
V2NormInf(v2 v)
{
    f32 inv_length = 1.f/V2LengthInf(v);
    v2 result = { v.x*inv_length, v.y*inv_length, };
    return result;
}
internal v3
V3NormInf(v3 v)
{
    f32 inv_length = 1.f/V3LengthInf(v);
    v3 result = { v.x*inv_length, v.y*inv_length, v.z*inv_length, };
    return result;
}
internal v4
V4NormInf(v4 v)
{
    f32 inv_length = 1.f/V4LengthInf(v);
    v4 result = { v.x*inv_length, v.y*inv_length, v.z*inv_length, v.w*inv_length, };
    return result;
}

internal v3
V3Cross(v3 a, v3 b)
{
    v3 result =
    {
        a.y*b.z - a.z*b.y,
        a.z*b.x - a.x*b.z,
        a.x*b.y - a.y*b.x,
    };
    return result;
}

////////////////////////////////
// NOTE(allen): matrix

internal m4
M4InitD(f32 diagonal)
{
    m4 m =
    {
        {
            { diagonal                },
            { 0.f, diagonal           },
            { 0.f, 0.f, diagonal      },
            { 0.f, 0.f, 0.f, diagonal },
        }
    };
    return m;
}

internal m4
M4MultiplyM4(m4 a, m4 b)
{
    m4 c = {0};
    
    for(int j = 0; j < 4; ++j)
    {
        for(int i = 0; i < 4; ++i)
        {
            c.elements[i][j] = (a.elements[0][j]*b.elements[i][0] +
                                a.elements[1][j]*b.elements[i][1] +
                                a.elements[2][j]*b.elements[i][2] +
                                a.elements[3][j]*b.elements[i][3]);
        }
    }
    
    return c;
}

internal m4
M4MultiplyF32(m4 a, f32 b)
{
    for(int j = 0; j < 4; ++j)
    {
        for(int i = 0; i < 4; ++i)
        {
            a.elements[i][j] *= b;
        }
    }
    
    return a;
}

internal v4
V4MultiplyM4(v4 v, m4 m)
{
    v4 result = {0};
    
    for(int i = 0; i < 4; ++i)
    {
        result.elements[i] = (v.elements[0]*m.elements[0][i] +
                              v.elements[1]*m.elements[1][i] +
                              v.elements[2]*m.elements[2][i] +
                              v.elements[3]*m.elements[3][i]);
    }
    
    return result;
}

internal m4
M4TranslateV3(v3 translation)
{
    m4 result = M4InitD(1.f);
    result.elements[3][0] = translation.x;
    result.elements[3][1] = translation.y;
    result.elements[3][2] = translation.z;
    return result;
}

internal m4
M4ScaleV3(v3 scale)
{
    m4 result = M4InitD(1.f);
    result.elements[0][0] = scale.x;
    result.elements[1][1] = scale.y;
    result.elements[2][2] = scale.z;
    return result;
}

internal m4
M4Perspective(f32 fov, f32 aspect_ratio, f32 near_z, f32 far_z)
{
    m4 result = {0};
    f32 tan_theta_over_2 = Tan(fov * (PI / 360.f));
    result.elements[0][0] = 1.f / tan_theta_over_2;
    result.elements[1][1] = aspect_ratio / tan_theta_over_2;
    result.elements[2][3] = -1.f;
    result.elements[2][2] = (near_z + far_z) / (near_z - far_z);
    result.elements[3][2] = (2.f * near_z * far_z) / (near_z - far_z);
    result.elements[3][3] = 0.f;
    return result;
}

internal m4
M4LookAt(v3 eye, v3 center, v3 up)
{
    m4 result;
    
    v3 f = V3Normalize(V3Sub(center, eye));
    v3 s = V3Normalize(V3Cross(f, up));
    v3 u = V3Cross(s, f);
    
    result.elements[0][0] = s.x;
    result.elements[0][1] = u.x;
    result.elements[0][2] = -f.x;
    result.elements[0][3] = 0.0f;
    
    result.elements[1][0] = s.y;
    result.elements[1][1] = u.y;
    result.elements[1][2] = -f.y;
    result.elements[1][3] = 0.0f;
    
    result.elements[2][0] = s.z;
    result.elements[2][1] = u.z;
    result.elements[2][2] = -f.z;
    result.elements[2][3] = 0.0f;
    
    result.elements[3][0] = -V3Dot(s, eye);
    result.elements[3][1] = -V3Dot(u, eye);
    result.elements[3][2] = V3Dot(f, eye);
    result.elements[3][3] = 1.0f;
    
    return result;
}

internal m4
M4Inverse(m4 m)
{
    f32 coef00 = m.elements[2][2] * m.elements[3][3] - m.elements[3][2] * m.elements[2][3];
    f32 coef02 = m.elements[1][2] * m.elements[3][3] - m.elements[3][2] * m.elements[1][3];
    f32 coef03 = m.elements[1][2] * m.elements[2][3] - m.elements[2][2] * m.elements[1][3];
    f32 coef04 = m.elements[2][1] * m.elements[3][3] - m.elements[3][1] * m.elements[2][3];
    f32 coef06 = m.elements[1][1] * m.elements[3][3] - m.elements[3][1] * m.elements[1][3];
    f32 coef07 = m.elements[1][1] * m.elements[2][3] - m.elements[2][1] * m.elements[1][3];
    f32 coef08 = m.elements[2][1] * m.elements[3][2] - m.elements[3][1] * m.elements[2][2];
    f32 coef10 = m.elements[1][1] * m.elements[3][2] - m.elements[3][1] * m.elements[1][2];
    f32 coef11 = m.elements[1][1] * m.elements[2][2] - m.elements[2][1] * m.elements[1][2];
    f32 coef12 = m.elements[2][0] * m.elements[3][3] - m.elements[3][0] * m.elements[2][3];
    f32 coef14 = m.elements[1][0] * m.elements[3][3] - m.elements[3][0] * m.elements[1][3];
    f32 coef15 = m.elements[1][0] * m.elements[2][3] - m.elements[2][0] * m.elements[1][3];
    f32 coef16 = m.elements[2][0] * m.elements[3][2] - m.elements[3][0] * m.elements[2][2];
    f32 coef18 = m.elements[1][0] * m.elements[3][2] - m.elements[3][0] * m.elements[1][2];
    f32 coef19 = m.elements[1][0] * m.elements[2][2] - m.elements[2][0] * m.elements[1][2];
    f32 coef20 = m.elements[2][0] * m.elements[3][1] - m.elements[3][0] * m.elements[2][1];
    f32 coef22 = m.elements[1][0] * m.elements[3][1] - m.elements[3][0] * m.elements[1][1];
    f32 coef23 = m.elements[1][0] * m.elements[2][1] - m.elements[2][0] * m.elements[1][1];
    
    v4 fac0 = { coef00, coef00, coef02, coef03 };
    v4 fac1 = { coef04, coef04, coef06, coef07 };
    v4 fac2 = { coef08, coef08, coef10, coef11 };
    v4 fac3 = { coef12, coef12, coef14, coef15 };
    v4 fac4 = { coef16, coef16, coef18, coef19 };
    v4 fac5 = { coef20, coef20, coef22, coef23 };
    
    v4 vec0 = { m.elements[1][0], m.elements[0][0], m.elements[0][0], m.elements[0][0] };
    v4 vec1 = { m.elements[1][1], m.elements[0][1], m.elements[0][1], m.elements[0][1] };
    v4 vec2 = { m.elements[1][2], m.elements[0][2], m.elements[0][2], m.elements[0][2] };
    v4 vec3 = { m.elements[1][3], m.elements[0][3], m.elements[0][3], m.elements[0][3] };
    
    v4 inv0 = V4Add(V4Sub(V4Hadamard(vec1, fac0), V4Hadamard(vec2, fac1)), V4Hadamard(vec3, fac2));
    v4 inv1 = V4Add(V4Sub(V4Hadamard(vec0, fac0), V4Hadamard(vec2, fac3)), V4Hadamard(vec3, fac4));
    v4 inv2 = V4Add(V4Sub(V4Hadamard(vec0, fac1), V4Hadamard(vec1, fac3)), V4Hadamard(vec3, fac5));
    v4 inv3 = V4Add(V4Sub(V4Hadamard(vec0, fac2), V4Hadamard(vec1, fac4)), V4Hadamard(vec2, fac5));
    
    v4 sign_a = { +1, -1, +1, -1 };
    v4 sign_b = { -1, +1, -1, +1 };
    
    m4 inverse;
    for(u32 i = 0; i < 4; ++i)
    {
        inverse.elements[0][i] = inv0.elements[i] * sign_a.elements[i];
        inverse.elements[1][i] = inv1.elements[i] * sign_b.elements[i];
        inverse.elements[2][i] = inv2.elements[i] * sign_a.elements[i];
        inverse.elements[3][i] = inv3.elements[i] * sign_b.elements[i];
    }
    
    v4 row0 = { inverse.elements[0][0], inverse.elements[1][0], inverse.elements[2][0], inverse.elements[3][0] };
    v4 m0 = { m.elements[0][0], m.elements[0][1], m.elements[0][2], m.elements[0][3] };
    v4 dot0 = V4Hadamard(m0, row0);
    f32 dot1 = (dot0.x + dot0.y) + (dot0.z + dot0.w);
    
    f32 one_over_det = 1 / dot1;
    
    return M4MultiplyF32(inverse, one_over_det);
}

internal m4
M4RemoveRotation(m4 mat)
{
    v3 scale =
    {
        V3Length(v3(mat.elements[0][0], mat.elements[0][1], mat.elements[0][2])),
        V3Length(v3(mat.elements[1][0], mat.elements[1][1], mat.elements[1][2])),
        V3Length(v3(mat.elements[2][0], mat.elements[2][1], mat.elements[2][2])),
    };
    
    mat.elements[0][0] = scale.x;
    mat.elements[1][0] = 0.f;
    mat.elements[2][0] = 0.f;
    
    mat.elements[0][1] = 0.f;
    mat.elements[1][1] = scale.y;
    mat.elements[2][1] = 0.f;
    
    mat.elements[0][2] = 0.f;
    mat.elements[1][2] = 0.f;
    mat.elements[2][2] = scale.z;
    
    return mat;
}

////////////////////////////////
// NOTE(allen): color

internal v3
RGBToHSV(v3 rgb)
{
    f32 c_max = V3Max(rgb);
    f32 c_min = V3Min(rgb);
    f32 delta = c_max - c_min;
    b32 c_max_is_r = rgb.r > rgb.g && rgb.r > rgb.b;
    b32 c_max_is_g = rgb.g > rgb.r && rgb.g > rgb.b;
    b32 c_max_is_b = rgb.b > rgb.r && rgb.b > rgb.g;
    f32 h = (c_max_is_r ? (rgb.g - rgb.b) / delta + 0 : c_max_is_g ? (rgb.b - rgb.r) / delta + 2 : c_max_is_b ? (rgb.r - rgb.g) / delta + 4 : 0);
    f32 s = c_max == 0 ? 0 : (delta / c_max);
    f32 v = c_max;
    v3 hsv = {h / 6.f, s, v};
    return hsv;
}

internal v3
HSVToRGB(v3 hsv)
{
    f32 h = FMod(hsv.x * 360.f, 360.f);
    f32 s = hsv.y;
    f32 v = hsv.z;
    
    f32 c = v * s;
    f32 x = c * (1 - AbsoluteValue(FMod((h / 60.f), 2) - 1));
    f32 m = v - c;
    
    f32 r;
    f32 g;
    f32 b;
    
    if((h >= 0.f && h < 60.f) || (h >= 360.f && h < 420.f))
    {
        r = c;
        g = x;
        b = 0;
    }
    else if(h >= 60.f && h < 120.f)
    {
        r = x;
        g = c;
        b = 0;
    }
    else if(h >= 120.f && h < 180.f)
    {
        r = 0;
        g = c;
        b = x;
    }
    else if(h >= 180.f && h < 240.f)
    {
        r = 0;
        g = x;
        b = c;
    }
    else if(h >= 240.f && h < 300.f)
    {
        r = x;
        g = 0;
        b = c;
    }
    else if((h >= 300.f && h <= 360.f) ||
            (h >= -60.f && h <= 0.f))
    {
        r = c;
        g = 0;
        b = x;
    }
    
    v3 rgb = {r + m, g + m, b + m};
    return rgb;
}

////////////////////////////////
// NOTE(allen): interval

internal Range
MakeRange(f32 a, f32 b)
{
    Range range = {a, b};
    if (a > b)
    {
        Swap(f32, range.min, range.max);
    }
    return(range);
}
internal Rangei
MakeRangei(i64 a, i64 b)
{
    Rangei range = {a, b};
    if (a > b)
    {
        Swap(i64, range.min, range.max);
    }
    return(range);
}
internal Rangeu
MakeRangeu(u64 a, u64 b)
{
    Rangeu range = {a, b};
    if (a > b)
    {
        Swap(u64, range.min, range.max);
    }
    return(range);
}

#define RangeSize(range) ((range).max - (range).min)

internal Range
RangeUnion(Range a, Range b)
{
    Range result;
    result.min = Min(a.min, b.min);
    result.max = Max(a.max, b.max);
    return(result);
}

internal Range
RangeIntersection(Range a, Range b)
{
    Range result;
    result.min = Max(a.min, b.min);
    result.max = Min(a.max, b.max);
    result.min = ClampTop(result.min, result.max);
    return(result);
}

internal Range
RangeGrow(Range range, f32 x)
{
    range.min -= x;
    range.max += x;
    return(range);
}

internal Range
RangeShrink(Range range, f32 x)
{
    range.min += x;
    range.max -= x;
    range.min = ClampTop(range.min, range.max);
    return(range);
}

internal Range
RangeSplit(Range *free_range, Side side, f32 amt){
    Range range;
    if (side == Side_Min){
        range.min = free_range->min;
        range.max = range.min + amt;
        range.max = ClampTop(range.max, free_range->max);
        free_range->min = range.max;
    }
    else{
        range.max = free_range->max;
        range.min = range.max - amt;
        range.min = ClampBot(range.min, free_range->min);
        free_range->max = range.min;
    }
    return(range);
}

internal b32
RangeContains(Range range, f32 x)
{
    return(range.min <= x && x < range.max);
}

internal b32
RangeOverlaps(Range a, Range b)
{
    return(a.min < b.max && b.min < a.max);
}

internal b32
RangeuContains(Rangeu range, u64 x)
{
    return(range.min <= x && x < range.max);
}

internal Rect
MakeRect(f32 x0, f32 y0, f32 x1, f32 y1)
{
    Rect rect = {x0, y0, x1, y1};
    return(rect);
}
internal Rect
MakeRectVec(v2 p0, v2 p1)
{
    Rect rect = {p0.x, p0.y, p1.x, p1.y};
    return(rect);
}
internal Rect
MakeRectRanges(Range x, Range y)
{
    Rect rect = {x.min, y.min, x.max, y.max};
    return(rect);
}

internal Rect
RectUnion(Rect a, Rect b)
{
    Rect result;
    result.x0 = Min(a.x0, b.x0);
    result.y0 = Min(a.y0, b.y0);
    result.x1 = Max(a.x1, b.x1);
    result.y1 = Max(a.y1, b.y1);
    return(result);
}

internal Rect
RectIntersect(Rect a, Rect b)
{
    Rect result;
    result.x0 = Max(a.x0, b.x0);
    result.y0 = Max(a.y0, b.y0);
    result.x1 = Min(a.x1, b.x1);
    result.y1 = Min(a.y1, b.y1);
    result.x0 = ClampTop(result.x0, result.x1);
    result.y0 = ClampTop(result.y0, result.y1);
    return(result);
}

internal Rect
RectGrow(Rect rect, f32 v)
{
    rect.x0 -= v;
    rect.y0 -= v;
    rect.x1 += v;
    rect.y1 += v;
    return(rect);
}

internal Rect
RectShrink(Rect rect, f32 v)
{
    rect.x0 += v;
    rect.y0 += v;
    rect.x1 -= v;
    rect.y1 -= v;
    rect.x0 = ClampTop(rect.x0, rect.x1);
    rect.y0 = ClampTop(rect.y0, rect.y1);
    return(rect);
}

internal Range
RectGetRange(Rect rect, Dimension dim)
{
    Range range = {rect.p0.v[dim], rect.p1.v[dim]};
    return(range);
}

internal b32
RectContains(Rect rect, v2 p)
{
    return(rect.x0 <= p.x && p.x < rect.x1 && rect.y0 <= p.y && p.y < rect.y1);
}

internal b32
RectOverlaps(Rect a, Rect b)
{
    return(a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1);
}

internal v2
RectGetDim(Rect rect)
{
    v2 p = {rect.x1 - rect.x0, rect.y1 - rect.y0};
    return(p);
}
#define RectSize(r) RectGetDim(r)

internal v2
RectGetCenter(Rect rect)
{
    v2 p = {0.5f*(rect.x1 + rect.x0), 0.5f*(rect.y1 + rect.y0)};
    return(p);
}

////////////////////////////////
//~ NOTE(allen): String

internal b32
CharIsSpace(char c)
{
    return((c) <= 32);
}

internal b32
CharIsAlpha(char c)
{
    return ((c >= 'a' && c <= 'z') ||
            (c >= 'A' && c <= 'Z'));
}

internal b32
CharIsDigit(char c)
{
    return (c >= '0' && c <= '9');
}

internal b32
CharIsSymbol(char c)
{
    return (c == '~' ||
            c == '!' ||
            c == '%' ||
            c == '^' ||
            c == '&' ||
            c == '*' ||
            c == '(' ||
            c == ')' ||
            c == '[' ||
            c == ']' ||
            c == '{' ||
            c == '}' ||
            c == '-' ||
            c == '+' ||
            c == '=' ||
            c == ';' ||
            c == ':' ||
            c == '<' ||
            c == '>' ||
            c == '/' ||
            c == '?' ||
            c == '.' ||
            c == ',');
}

internal char
CharToLower(char c)
{
    if(c >= 'A' && c <= 'Z')
    {
        return c + 32;
    }
    return c;
}

internal char
CharToUpper(char c)
{
    if(c >= 'a' && c <= 'z')
    {
        return c - 32;
    }
    return c;
}

internal String8
S8(u8 *str, u64 size)
{
    String8 result = {str, size};
    return(result);
}

internal String8
S8Range(u8 *first, u8 *one_past_last)
{
    String8 result = {first, one_past_last - first};
    return(result);
}

internal String8
S8Zero(void){
    String8 result = {0, 0};
    return(result);
}

internal String8
String8FromCString(char *cstring)
{
    String8 string = {0};
    string.str = (u8 *)cstring;
    string.size = CalculateCStringLength(cstring);
    return string;
}

internal b32
StringMatchGeneric(String8 a, String8 b, StringMatchFlags flags)
{
    b32 result = 0;
    
    if(a.size == b.size || (flags & StringMatchFlag_RightSideSloppy))
    {
        b32 insensitive = (flags & StringMatchFlag_CaseInsensitive);
        u64 size = Min(a.size, b.size);
        result = 1;
        for(u64 i = 0; i < size; ++i)
        {
            u8 at = a.str[i];
            u8 bt = b.str[i];
            if(insensitive)
            {
                at = CharToUpper(at);
                bt = CharToUpper(bt);
            }
            if(at != bt)
            {
                result = 0;
                break;
            }
        }
    }
    
    return result;
}

internal b32
StringMatch(String8 a, String8 b)
{
    return StringMatchGeneric(a, b, 0);
}

internal b32
StringMatchCaseInsensitive(String8 a, String8 b)
{
    return StringMatchGeneric(a, b, StringMatchFlag_CaseInsensitive);
}

internal u64
StringFindSubstringStart(String8 a, String8 sub, StringMatchFlags flags)
{
    u64 result = ~(u64)0;
    for (u64 i = 0; i < a.size; i += 1){
        if (a.str[i] == sub.str[0]){
            if (StringMatchGeneric(a, sub, flags | StringMatchFlag_RightSideSloppy)){
                result = i;
                break;
            }
        }
    }
    return(result);
}

internal String8
StringSubstring(String8 string, Rangeu range)
{
    range.max = ClampTop(range.max, string.size);
    range.min = ClampTop(range.min, string.size);
    string.str += range.min;
    string.size = RangeSize(range);
    return(string);
}

internal String8
StringPrefix(String8 string, u64 size)
{
    string.size = ClampTop(size, string.size);
    return(string);
}

internal String8
StringSkip(String8 string, u64 val)
{
    val = ClampTop(val, string.size);
    string.str += val;
    string.size -= val;
    return(string);
}

internal String8
StringPostfix(String8 string, u64 size)
{
    size = ClampTop(size, string.size);
    string.str = (string.str + string.size) - size;
    string.size = size;
    return(string);
}

internal String8
StringChop(String8 string, u64 val)
{
    val = ClampTop(val, string.size);
    string.size -= val;
    return(string);
}

internal String8
PushStringCat(M_Arena *arena, String8 a, String8 b){
    String8 str;
    str.size = a.size + b.size;
    str.str = PushArray(arena, u8, str.size);
    MemoryCopy(str.str, a.str, a.size);
    MemoryCopy(str.str + a.size, b.str, b.size);
    return(str);
}

internal String8
PushStringFV(M_Arena *arena, char *format, va_list args)
{
    va_list args2;
    va_copy(args2, args);
    u32 needed_bytes = vsnprintf(0, 0, format, args) + 1;
    String8 result = {0};
    result.str = PushArray(arena, u8, needed_bytes);
    result.size = vsnprintf((char*)result.str, needed_bytes, format, args2);
    result.str[result.size] = 0;
    return(result);
}

internal String8
PushStringF(M_Arena *arena, char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    String8 result = PushStringFV(arena, fmt, args);
    va_end(args);
    return(result);
}

////////////////////////////////
//~ NOTE(allen): String List

internal String8_Node*
StringListPush(M_Arena *arena, String8_List *list, String8 string)
{
    String8_Node *node = PushArray(arena, String8_Node, 1);
    SLLQueuePush(list->first, list->last, node);
    list->node_count += 1;
    list->total_size += string.size;
    node->string = string;
    return(node);
}

internal String8_Node*
StringListPushFront(M_Arena *arena, String8_List *list, String8 string)
{
    String8_Node *node = PushArray(arena, String8_Node, 1);
    SLLQueuePushFront(list->first, list->last, node);
    list->node_count += 1;
    list->total_size += string.size;
    node->string = string;
    return(node);
}

internal String8_Node*
StringListPushF(M_Arena *arena, String8_List *list, char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    String8 string = PushStringFV(arena, fmt, args);
    String8_Node *result = StringListPush(arena, list, string);
    va_end(args);
    return(result);
}

internal String8_Node*
StringListPushFrontF(M_Arena *arena, String8_List *list, char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    String8 string = PushStringFV(arena, fmt, args);
    String8_Node *result = StringListPushFront(arena, list, string);
    va_end(args);
    return(result);
}

internal void
StringListRemoveEmpties(String8_List *list)
{
    String8_Node *new_first = 0;
    String8_Node *new_last = 0;
    u64 new_count = 0;
    for (String8_Node *node = list->first, *next = 0;
         node != 0;
         node = next)
    {
        next = node->next;
        if (node->string.size > 0){
            SLLQueuePush(new_first, new_last, node);
            new_count += 1;
        }
    }
    list->first = new_first;
    list->last = new_last;
    list->node_count = new_count;
}

internal String8_List
StringSplit(M_Arena *arena, String8 string, u8 *split_chars, u64 split_char_count)
{
    String8_List list = {0};
    
    u8 *ptr = string.str;
    u8 *opl = string.str + string.size;
    for (;ptr < opl;)
    {
        u8 *first = ptr;
        for (;ptr < opl; ptr += 1)
        {
            u8 c = *ptr;
            b32 is_split = 0;
            for (u64 i = 0; i < split_char_count; i += 1)
            {
                if (split_chars[i] == c)
                {
                    is_split = 1;
                    break;
                }
            }
            if (is_split)
            {
                break;
            }
        }
        
        StringListPush(arena, &list, S8Range(first, ptr));
        ptr += 1;
    }
    
    return(list);
}

internal String8
StringListJoin(M_Arena *arena, String8_List *list, String_Join *optional_join)
{
    String_Join join = {0};
    if (optional_join != 0)
    {
        MemoryCopyStruct(&join, optional_join);
    }
    
    String8 result;
    result.size = join.pre.size + join.post.size + (list->node_count - 1)*join.sep.size + list->total_size;
    u8 *ptr = result.str = PushArray(arena, u8, result.size);
    
    MemoryCopy(ptr, join.pre.str, join.pre.size);
    ptr += join.pre.size;
    for (String8_Node *node = list->first;
         node != 0;
         node = node->next)
    {
        MemoryCopy(ptr, node->string.str, node->string.size);
        ptr += node->string.size;
        if (node->next != 0)
        {
            MemoryCopy(ptr, join.sep.str, join.sep.size);
            ptr += join.sep.size;
        }
    }
    MemoryCopy(ptr, join.post.str, join.post.size);
    ptr += join.post.size;
    
    return(result);
}

////////////////////////////////
//~ NOTE(allen): Additional String Stuff

internal i64
GetFirstIntegerFromString(String8 string)
{
    i32 result = 0;
    b32 found_first_digit = 0;
    u32 integer_write_pos = 0;
    u8 integer[64] = {0};
    u32 read_pos = 0;
    for(;; ++read_pos)
    {
        if(string.str[read_pos] == 0)
        {
            break;
        }
        if(found_first_digit)
        {
            if(integer_write_pos == sizeof(integer))
            {
                integer[sizeof(integer) - 1] = 0;
                break;
            }
            if(CharIsDigit(string.str[read_pos]) || string.str[read_pos] == '-')
            {
                integer[integer_write_pos++] = string.str[read_pos];
            }
            else
            {
                integer[integer_write_pos++] = 0;
                break;
            }
        }
        else
        {
            if(CharIsDigit(string.str[read_pos]) || string.str[read_pos] == '-')
            {
                integer[integer_write_pos++] = string.str[read_pos];
                found_first_digit = 1;
            }
        }
    }
    result = CStringToI32(integer);
    return result;
}

internal f32
GetFirstF32FromCString(char *str)
{
    f32 result = 0;
    b32 found_first_digit = 0;
    u32 float_write_pos = 0;
    char float_str[64] = {0};
    u32 read_pos = 0;
    for(;; ++read_pos)
    {
        if(str[read_pos] == 0)
        {
            break;
        }
        if(found_first_digit)
        {
            if(float_write_pos == sizeof(float_str))
            {
                float_str[sizeof(float_str) - 1] = 0;
                break;
            }
            if(CharIsDigit(str[read_pos]) || str[read_pos] == '.' || str[read_pos] == '-')
            {
                float_str[float_write_pos++] = str[read_pos];
            }
            else
            {
                float_str[float_write_pos++] = 0;
                break;
            }
        }
        else
        {
            if(CharIsDigit(str[read_pos]) || str[read_pos] == '.' || str[read_pos] == '-')
            {
                float_str[float_write_pos++] = str[read_pos];
                found_first_digit = 1;
            }
        }
    }
    result = CStringToF32(float_str);
    return result;
}

internal void
CopySubstringToStringUntilCharN(char *str1, u32 str1_max,
                                const char *str2, char str2_term)
{
    u32 write_pos = 0;
    while(1)
    {
        if(str2[write_pos] == str2_term || write_pos == str1_max - 1)
        {
            str1[write_pos++] = 0;
            break;
        }
        else
        {
            str1[write_pos] = str2[write_pos];
            ++write_pos;
        }
    }
}

internal void
CopyStringToFixedSizeBuffer(char *dest, u32 dest_max,
                            const char *src)
{
    u32 read_pos = 0;
    u32 write_pos = 0;
    for(;;)
    {
        if(src[read_pos] == 0 || write_pos >= dest_max)
        {
            break;
        }
        dest[write_pos++] = src[read_pos++];
    }
    if(write_pos >= dest_max)
    {
        dest[dest_max - 1] = 0;
    }
    else
    {
        dest[write_pos++] = 0;
    }
}

internal u32
CStringIndexAfterSubstring(char *str, char *substr)
{
    u32 result = 0;
    for(u32 i = 0; str[i]; ++i)
    {
        if(str[i] == substr[0])
        {
            if(CStringMatchCaseInsensitiveN(str + i, substr, CalculateCStringLength(substr)))
            {
                result = i + CalculateCStringLength(substr);
            }
        }
    }
    return result;
}

internal u32
CStringFirstIndexAfterSubstring(char *str, char *substr)
{
    u32 result = 0;
    for(u32 i = 0; str[i]; ++i)
    {
        if(str[i] == substr[0])
        {
            if(CStringMatchCaseInsensitiveN(str + i, substr, CalculateCStringLength(substr)))
            {
                result = i + CalculateCStringLength(substr);
                break;
            }
        }
    }
    return result;
}

internal void
CopyCStringToFixedSizeBuffer(char *destination, u32 destination_max, char *source)
{
    for(u32 i = 0; i < destination_max; ++i)
    {
        destination[i] = source[i];
        if(source[i] == 0)
        {
            break;
        }
    }
    destination[destination_max-1] = 0;
}

internal void
CopyCStringToFixedSizeBufferN(char *destination, u32 destination_max, char *source, u32 source_max)
{
    for(u32 i = 0; i < destination_max && i < source_max; ++i)
    {
        destination[i] = source[i];
        if(source[i] == 0)
        {
            break;
        }
    }
    destination[destination_max-1] = 0;
}

internal char *
ConvertCStringToLowercase(char *str)
{
    for(int i = 0; str[i]; ++i)
    {
        str[i] = CharToLower(str[i]);
    }
    return str;
}

internal char *
ConvertCStringToUppercase(char *str)
{
    for(int i = 0; str[i]; ++i)
    {
        str[i] = CharToUpper(str[i]);
    }
    return str;
}

internal char *
ConvertCStringToLowercaseWithUnderscores(char *str)
{
    for(int i = 0; str[i]; ++i)
    {
        if(str[i] == ' ')
        {
            str[i] = '_';
        }
        else
        {
            str[i] = CharToLower(str[i]);
        }
    }
    return str;
}

static unsigned int global_crc32_table[] =
{
    0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
    0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
    0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
    0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
    0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
    0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
    0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
    0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
    0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
    0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
    0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
    0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
    0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
    0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
    0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
    0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
    0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
    0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
    0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
    0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
    0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
    0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
    0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
    0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
    0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
    0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
    0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
    0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
    0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
    0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
    0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
    0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
    0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
    0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
    0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
    0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
    0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
    0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
    0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
    0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
    0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
    0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
    0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
    0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
    0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
    0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
    0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
    0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
    0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
    0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
    0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
    0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
    0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
    0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
    0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
    0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
    0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
    0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
    0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
    0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
    0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
    0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
    0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
    0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4,
};

internal u32
CStringCRC32N(char *name, u32 n)
{
    u32 crc = 0;
    for(u32 i = 0; name[i] && i < n; ++i)
    {
        crc = (crc << 8) ^ global_crc32_table[((crc >> 24) ^ name[i]) & 255];
    }
    return crc;
}

internal u32
CStringCRC32(char *name)
{
    return CStringCRC32N(name, (u32)(u32)(-1));
}

internal void
AppendToFixedSizeCString(char *destination, u32 destination_max, char *str)
{
    u32 i = 0;
    for(; i < destination_max && destination[i]; ++i);
    if(destination_max > i)
    {
        CopyCStringToFixedSizeBuffer(destination + i, destination_max - i, str);
    }
}