715 lines
16 KiB
C++
715 lines
16 KiB
C++
//- sixten: V2 R32
|
|
|
|
inline v2_r32 V2R32(r32 x, r32 y)
|
|
{
|
|
v2_r32 Result = {x, y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 operator+(v2_r32 A, v2_r32 B)
|
|
{
|
|
v2_r32 Result = {A.x + B.x, A.y + B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 operator-(v2_r32 A, v2_r32 B)
|
|
{
|
|
v2_r32 Result = {A.x - B.x, A.y - B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 operator*(v2_r32 A, v2_r32 B)
|
|
{
|
|
v2_r32 Result = {A.x * B.x, A.y * B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 operator/(v2_r32 A, v2_r32 B)
|
|
{
|
|
v2_r32 Result = {A.x / B.x, A.y / B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 operator*(v2_r32 A, r32 B)
|
|
{
|
|
v2_r32 Result = {A.x * B, A.y * B};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 operator+=(v2_r32 &A, v2_r32 B) { return A = A + B; }
|
|
inline v2_r32 operator-=(v2_r32 &A, v2_r32 B) { return A = A - B; }
|
|
inline v2_r32 operator*=(v2_r32 &A, v2_r32 B) { return A = A * B; }
|
|
inline v2_r32 operator/=(v2_r32 &A, v2_r32 B) { return A = A / B; }
|
|
inline v2_r32 operator*=(v2_r32 &A, r32 B) { return A = A * B; }
|
|
|
|
inline r32 Inner(v2_r32 A, v2_r32 B)
|
|
{
|
|
r32 Result = A.x*B.x + A.y*B.y;
|
|
return(Result);
|
|
}
|
|
|
|
inline r32 LengthSquared(v2_r32 V)
|
|
{
|
|
r32 Result = Inner(V, V);
|
|
return(Result);
|
|
}
|
|
|
|
inline r32 Length(v2_r32 V)
|
|
{
|
|
r32 Result = SquareRoot(LengthSquared(V));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 NOZ(v2_r32 V)
|
|
{
|
|
v2_r32 Result = {};
|
|
|
|
r32 Len = Length(V);
|
|
if(Len != 0)
|
|
{
|
|
Result = V / V2R32(Len, Len);
|
|
}
|
|
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 LinearBlend(v2_r32 A, v2_r32 B, r32 x)
|
|
{
|
|
v2_r32 Result = A+(B-A)*x;
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 Min(v2_r32 A, v2_r32 B)
|
|
{
|
|
v2_r32 Result = V2R32(Min(A.x, B.x), Min(A.y, B.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 Max(v2_r32 A, v2_r32 B)
|
|
{
|
|
v2_r32 Result = V2R32(Max(A.x, B.x), Max(A.y, B.y));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V2 S32
|
|
|
|
inline v2_s32 V2S32(s32 x, s32 y)
|
|
{
|
|
v2_s32 Result = {x, y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s32 operator+(v2_s32 A, v2_s32 B)
|
|
{
|
|
v2_s32 Result = {A.x + B.x, A.y + B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s32 operator-(v2_s32 A, v2_s32 B)
|
|
{
|
|
v2_s32 Result = {A.x - B.x, A.y - B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s32 operator+=(v2_s32 &A, v2_s32 B) { return A = A + B; }
|
|
inline v2_s32 operator-=(v2_s32 &A, v2_s32 B) { return A = A - B; }
|
|
|
|
inline v2_s32 Min(v2_s32 A, v2_s32 B)
|
|
{
|
|
v2_s32 Result = V2S32(Min(A.x, B.x), Min(A.y, B.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s32 Max(v2_s32 A, v2_s32 B)
|
|
{
|
|
v2_s32 Result = V2S32(Max(A.x, B.x), Max(A.y, B.y));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V2 S64
|
|
|
|
inline v2_s64 V2S64(s64 x, s64 y)
|
|
{
|
|
v2_s64 Result = {x, y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s64 operator+(v2_s64 A, v2_s64 B)
|
|
{
|
|
v2_s64 Result = {A.x + B.x, A.y + B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s64 operator-(v2_s64 A, v2_s64 B)
|
|
{
|
|
v2_s64 Result = {A.x - B.x, A.y - B.y};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s64 operator+=(v2_s64 &A, v2_s64 B) { return A = A + B; }
|
|
inline v2_s64 operator-=(v2_s64 &A, v2_s64 B) { return A = A - B; }
|
|
|
|
inline v2_s64 Min(v2_s64 A, v2_s64 B)
|
|
{
|
|
v2_s64 Result = V2S64(Min(A.x, B.x), Min(A.y, B.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s64 Max(v2_s64 A, v2_s64 B)
|
|
{
|
|
v2_s64 Result = V2S64(Max(A.x, B.x), Max(A.y, B.y));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V3 R32
|
|
|
|
inline v3_r32 V3R32(r32 x, r32 y, r32 z)
|
|
{
|
|
v3_r32 Result = {x, y, z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 operator+(v3_r32 A, v3_r32 B)
|
|
{
|
|
v3_r32 Result = {A.x + B.x, A.y + B.y, A.z + B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 operator-(v3_r32 A, v3_r32 B)
|
|
{
|
|
v3_r32 Result = {A.x - B.x, A.y - B.y, A.z - B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 operator*(v3_r32 A, v3_r32 B)
|
|
{
|
|
v3_r32 Result = {A.x * B.x, A.y * B.y, A.z * B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 operator/(v3_r32 A, v3_r32 B)
|
|
{
|
|
v3_r32 Result = {A.x / B.x, A.y / B.y, A.z / B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 operator*(v3_r32 A, r32 B)
|
|
{
|
|
v3_r32 Result = {A.x * B, A.y * B, A.z * B};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 operator+=(v3_r32 &A, v3_r32 B) { return A = A + B; }
|
|
inline v3_r32 operator-=(v3_r32 &A, v3_r32 B) { return A = A - B; }
|
|
inline v3_r32 operator*=(v3_r32 &A, v3_r32 B) { return A = A * B; }
|
|
inline v3_r32 operator/=(v3_r32 &A, v3_r32 B) { return A = A / B; }
|
|
inline v3_r32 operator*=(v3_r32 &A, r32 B) { return A = A * B; }
|
|
|
|
inline r32 Inner(v3_r32 A, v3_r32 B)
|
|
{
|
|
r32 Result = A.x*B.x + A.y*B.y + A.z*B.z;
|
|
return(Result);
|
|
}
|
|
|
|
inline r32 LengthSquared(v3_r32 V)
|
|
{
|
|
r32 Result = Inner(V, V);
|
|
return(Result);;
|
|
}
|
|
|
|
inline r32 Length(v3_r32 V)
|
|
{
|
|
r32 Result = SquareRoot(LengthSquared(V));
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 NOZ(v3_r32 V)
|
|
{
|
|
v3_r32 Result = {};
|
|
|
|
r32 Len = Length(V);
|
|
if(Len != 0)
|
|
{
|
|
Result = V / V3R32(Len, Len, Len);
|
|
}
|
|
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 LinearBlend(v3_r32 A, v3_r32 B, r32 x)
|
|
{
|
|
v3_r32 Result = A+(B-A)*x;
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 Min(v3_r32 A, v3_r32 B)
|
|
{
|
|
v3_r32 Result = V3R32(Min(A.x, B.x), Min(A.y, B.y), Min(A.z, B.z));
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_r32 Max(v3_r32 A, v3_r32 B)
|
|
{
|
|
v3_r32 Result = V3R32(Max(A.x, B.x), Max(A.y, B.y), Max(A.z, B.z));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V3 S32
|
|
|
|
inline v3_s32 V3S32(s32 x, s32 y, s32 z)
|
|
{
|
|
v3_s32 Result = {x, y, z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s32 operator+(v3_s32 A, v3_s32 B)
|
|
{
|
|
v3_s32 Result = {A.x + B.x, A.y + B.y, A.z + B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s32 operator-(v3_s32 A, v3_s32 B)
|
|
{
|
|
v3_s32 Result = {A.x - B.x, A.y - B.y, A.z - B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s32 operator+=(v3_s32 &A, v3_s32 B) { return A = A + B; }
|
|
inline v3_s32 operator-=(v3_s32 &A, v3_s32 B) { return A = A - B; }
|
|
|
|
inline v3_s32 Min(v3_s32 A, v3_s32 B)
|
|
{
|
|
v3_s32 Result = V3S32(Min(A.x, B.x), Min(A.y, B.y), Min(A.z, B.z));
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s32 Max(v3_s32 A, v3_s32 B)
|
|
{
|
|
v3_s32 Result = V3S32(Max(A.x, B.x), Max(A.y, B.y), Max(A.z, B.z));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V3 S64
|
|
|
|
inline v3_s64 V4S64(s64 x, s64 y, s64 z)
|
|
{
|
|
v3_s64 Result = {x, y, z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s64 operator+(v3_s64 A, v3_s64 B)
|
|
{
|
|
v3_s64 Result = {A.x + B.x, A.y + B.y, A.z + B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s64 operator-(v3_s64 A, v3_s64 B)
|
|
{
|
|
v3_s64 Result = {A.x - B.x, A.y - B.y, A.z - B.z};
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s64 operator+=(v3_s64 &A, v3_s64 B) { return A = A + B; }
|
|
inline v3_s64 operator-=(v3_s64 &A, v3_s64 B) { return A = A - B; }
|
|
|
|
inline v3_s64 Min(v3_s64 A, v3_s64 B)
|
|
{
|
|
v3_s64 Result = V4S64(Min(A.x, B.x), Min(A.y, B.y), Min(A.z, B.z));
|
|
return(Result);
|
|
}
|
|
|
|
inline v3_s64 Max(v3_s64 A, v3_s64 B)
|
|
{
|
|
v3_s64 Result = V4S64(Max(A.x, B.x), Max(A.y, B.y), Max(A.z, B.z));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V4 R32
|
|
|
|
inline v4_r32 V4R32(r32 x, r32 y, r32 z, r32 w)
|
|
{
|
|
v4_r32 Result = {x, y, z, w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 operator+(v4_r32 A, v4_r32 B)
|
|
{
|
|
v4_r32 Result = {A.x + B.x, A.y + B.y, A.z + B.z, A.w + B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 operator-(v4_r32 A, v4_r32 B)
|
|
{
|
|
v4_r32 Result = {A.x - B.x, A.y - B.y, A.z - B.z, A.w - B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 operator*(v4_r32 A, v4_r32 B)
|
|
{
|
|
v4_r32 Result = {A.x * B.x, A.y * B.y, A.z * B.z, A.w * B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 operator/(v4_r32 A, v4_r32 B)
|
|
{
|
|
v4_r32 Result = {A.x / B.x, A.y / B.y, A.z / B.z, A.w / B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 operator*(v4_r32 A, r32 B)
|
|
{
|
|
v4_r32 Result = {A.x * B, A.y * B, A.z * B, A.w * B};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 operator+=(v4_r32 &A, v4_r32 B) { return A = A + B; }
|
|
inline v4_r32 operator-=(v4_r32 &A, v4_r32 B) { return A = A - B; }
|
|
inline v4_r32 operator*=(v4_r32 &A, v4_r32 B) { return A = A * B; }
|
|
inline v4_r32 operator/=(v4_r32 &A, v4_r32 B) { return A = A / B; }
|
|
inline v4_r32 operator*=(v4_r32 &A, r32 B) { return A = A * B; }
|
|
|
|
inline r32 Inner(v4_r32 A, v4_r32 B)
|
|
{
|
|
r32 Result = A.x*B.x + A.y*B.y + A.z*B.z + A.w*B.w;
|
|
return(Result);
|
|
}
|
|
|
|
inline r32 LengthSquared(v4_r32 V)
|
|
{
|
|
r32 Result = Inner(V, V);
|
|
return(Result);;
|
|
}
|
|
|
|
inline r32 Length(v4_r32 V)
|
|
{
|
|
r32 Result = SquareRoot(LengthSquared(V));
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 NOZ(v4_r32 V)
|
|
{
|
|
v4_r32 Result = {};
|
|
|
|
r32 Len = Length(V);
|
|
if(Len != 0)
|
|
{
|
|
Result = V / V4R32(Len, Len, Len, Len);
|
|
}
|
|
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 LinearBlend(v4_r32 A, v4_r32 B, r32 x)
|
|
{
|
|
v4_r32 Result = A+(B-A)*x;
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 Min(v4_r32 A, v4_r32 B)
|
|
{
|
|
v4_r32 Result = V4R32(Min(A.x, B.x), Min(A.y, B.y), Min(A.z, B.z), Min(A.w, B.w));
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_r32 Max(v4_r32 A, v4_r32 B)
|
|
{
|
|
v4_r32 Result = V4R32(Max(A.x, B.x), Max(A.y, B.y), Max(A.z, B.z), Max(A.w, B.w));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V4 S32
|
|
|
|
inline v4_s32 V4S32(s32 x, s32 y, s32 z, s32 w)
|
|
{
|
|
v4_s32 Result = {x, y, z, w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s32 operator+(v4_s32 A, v4_s32 B)
|
|
{
|
|
v4_s32 Result = {A.x + B.x, A.y + B.y, A.z + B.z, A.w + B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s32 operator-(v4_s32 A, v4_s32 B)
|
|
{
|
|
v4_s32 Result = {A.x - B.x, A.y - B.y, A.z - B.z, A.w - B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s32 operator+=(v4_s32 &A, v4_s32 B) { return A = A + B; }
|
|
inline v4_s32 operator-=(v4_s32 &A, v4_s32 B) { return A = A - B; }
|
|
|
|
inline v4_s32 Min(v4_s32 A, v4_s32 B)
|
|
{
|
|
v4_s32 Result = V4S32(Min(A.x, B.x), Min(A.y, B.y), Min(A.z, B.z), Min(A.w, B.w));
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s32 Max(v4_s32 A, v4_s32 B)
|
|
{
|
|
v4_s32 Result = V4S32(Max(A.x, B.x), Max(A.y, B.y), Max(A.z, B.z), Max(A.w, B.w));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: V4 S64
|
|
|
|
inline v4_s64 V4S64(s64 x, s64 y, s64 z, s64 w)
|
|
{
|
|
v4_s64 Result = {x, y, z, w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s64 operator+(v4_s64 A, v4_s64 B)
|
|
{
|
|
v4_s64 Result = {A.x + B.x, A.y + B.y, A.z + B.z, A.w + B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s64 operator-(v4_s64 A, v4_s64 B)
|
|
{
|
|
v4_s64 Result = {A.x - B.x, A.y - B.y, A.z - B.z, A.w - B.w};
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s64 operator+=(v4_s64 &A, v4_s64 B) { return A = A + B; }
|
|
inline v4_s64 operator-=(v4_s64 &A, v4_s64 B) { return A = A - B; }
|
|
|
|
inline v4_s64 Min(v4_s64 A, v4_s64 B)
|
|
{
|
|
v4_s64 Result = V4S64(Min(A.x, B.x), Min(A.y, B.y), Min(A.z, B.z), Min(A.w, B.w));
|
|
return(Result);
|
|
}
|
|
|
|
inline v4_s64 Max(v4_s64 A, v4_s64 B)
|
|
{
|
|
v4_s64 Result = V4S64(Max(A.x, B.x), Max(A.y, B.y), Max(A.z, B.z), Max(A.w, B.w));
|
|
return(Result);
|
|
}
|
|
|
|
//- sixten: Range functions
|
|
|
|
inline range1_r32 Range1R32(r32 A, r32 B)
|
|
{
|
|
range1_r32 Result = {Min(A, B), Max(A, B)};
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 InRange(range1_r32 Range, r32 Value)
|
|
{
|
|
b32 Result = (Value >= Range.Min) && (Value < Range.Max);
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 Contains(range1_r32 Range, r32 Value)
|
|
{
|
|
b32 Result = (Value >= Range.Min) && (Value <= Range.Max);
|
|
return(Result);
|
|
}
|
|
|
|
inline r32 DimOfRange(range1_r32 Range)
|
|
{
|
|
r32 Result = Range.Max - Range.Min;
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_r32 Intersection(range1_r32 A, range1_r32 B)
|
|
{
|
|
range1_r32 Result = {Max(A.Min, B.Min), Min(A.Max, B.Max)};
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_r32 Pad(range1_r32 Range, r32 Value)
|
|
{
|
|
range1_r32 Result = Range1R32(Range.Min-Value, Range.Max+Value);
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_s32 Range1S32(s32 A, s32 B)
|
|
{
|
|
range1_s32 Result = {Min(A, B), Max(A, B)};
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 InRange(range1_s32 Range, s32 Value)
|
|
{
|
|
b32 Result = (Value >= Range.Min) && (Value < Range.Max);
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 Contains(range1_s32 Range, s32 Value)
|
|
{
|
|
b32 Result = (Value >= Range.Min) && (Value <= Range.Max);
|
|
return(Result);
|
|
}
|
|
|
|
inline s32 DimOfRange(range1_s32 Range)
|
|
{
|
|
s32 Result = Range.Max - Range.Min;
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_s32 Intersection(range1_s32 A, range1_s32 B)
|
|
{
|
|
range1_s32 Result = {Max(A.Min, B.Min), Min(A.Max, B.Max)};
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_s32 Pad(range1_s32 Range, s32 Value)
|
|
{
|
|
range1_s32 Result = Range1S32(Range.Min-Value, Range.Max+Value);
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_s64 Range1S64(s64 A, s64 B)
|
|
{
|
|
range1_s64 Result = {Min(A, B), Max(A, B)};
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 InRange(range1_s64 Range, s64 Value)
|
|
{
|
|
b32 Result = (Value >= Range.Min) && (Value < Range.Max);
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 Contains(range1_s64 Range, s64 Value)
|
|
{
|
|
b32 Result = (Value >= Range.Min) && (Value <= Range.Max);
|
|
return(Result);
|
|
}
|
|
|
|
inline s64 DimOfRange(range1_s64 Range)
|
|
{
|
|
s64 Result = Range.Max - Range.Min;
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_s64 Intersection(range1_s64 A, range1_s64 B)
|
|
{
|
|
range1_s64 Result = {Max(A.Min, B.Min), Min(A.Max, B.Max)};
|
|
return(Result);
|
|
}
|
|
|
|
inline range1_s64 Pad(range1_s64 Range, s64 Value)
|
|
{
|
|
range1_s64 Result = Range1S64(Range.Min-Value, Range.Max+Value);
|
|
return(Result);
|
|
}
|
|
|
|
inline range2_r32 Range2R32(v2_r32 A, v2_r32 B)
|
|
{
|
|
range2_r32 Result = {Min(A, B), Max(A, B)};
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 InRange(range2_r32 Range, v2_r32 Value)
|
|
{
|
|
b32 Result = ((Value.x >= Range.Min.x) && (Value.y >= Range.Min.y) &&
|
|
(Value.x < Range.Max.x) && (Value.y < Range.Max.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 Contains(range2_r32 Range, v2_r32 Value)
|
|
{
|
|
b32 Result = ((Value.x >= Range.Min.x) && (Value.y >= Range.Min.y) &&
|
|
(Value.x <= Range.Max.x) && (Value.y <= Range.Max.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 DimOfRange(range2_r32 Range)
|
|
{
|
|
v2_r32 Result = Range.Max - Range.Min;
|
|
return(Result);
|
|
}
|
|
|
|
inline range2_r32 Intersection(range2_r32 A, range2_r32 B)
|
|
{
|
|
range2_r32 Result = {Max(A.Min, B.Min), Min(A.Max, B.Max)};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_r32 CornerFromRange(range2_r32 Range, corner Corner)
|
|
{
|
|
v2_r32 Result = V2R32((Corner & (1 << Axis2_X))?Range.Min.x:Range.Max.x,
|
|
(Corner & (1 << Axis2_Y))?Range.Min.y:Range.Max.y);
|
|
return(Result);
|
|
}
|
|
|
|
inline range2_s32 Range2S32(v2_s32 A, v2_s32 B)
|
|
{
|
|
range2_s32 Result = {Min(A, B), Max(A, B)};
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 InRange(range2_s32 Range, v2_s32 Value)
|
|
{
|
|
b32 Result = ((Value.x >= Range.Min.x) && (Value.y >= Range.Min.y) &&
|
|
(Value.x < Range.Max.x) && (Value.y < Range.Max.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 Contains(range2_s32 Range, v2_s32 Value)
|
|
{
|
|
b32 Result = ((Value.x >= Range.Min.x) && (Value.y >= Range.Min.y) &&
|
|
(Value.x <= Range.Max.x) && (Value.y <= Range.Max.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s32 DimOfRange(range2_s32 Range)
|
|
{
|
|
v2_s32 Result = Range.Max - Range.Min;
|
|
return(Result);
|
|
}
|
|
|
|
inline range2_s32 Intersection(range2_s32 A, range2_s32 B)
|
|
{
|
|
range2_s32 Result = {Max(A.Min, B.Min), Min(A.Max, B.Max)};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s32 CornerFromRange(range2_s32 Range, corner Corner)
|
|
{
|
|
v2_s32 Result = V2S32((Corner & (1 << Axis2_X))?Range.Min.x:Range.Max.x,
|
|
(Corner & (1 << Axis2_Y))?Range.Min.y:Range.Max.y);
|
|
return(Result);
|
|
}
|
|
|
|
inline range2_s64 Range2S64(v2_s64 A, v2_s64 B)
|
|
{
|
|
range2_s64 Result = {Min(A, B), Max(A, B)};
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 InRange(range2_s64 Range, v2_s64 Value)
|
|
{
|
|
b32 Result = ((Value.x >= Range.Min.x) && (Value.y >= Range.Min.y) &&
|
|
(Value.x < Range.Max.x) && (Value.y < Range.Max.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline b32 Contains(range2_s64 Range, v2_s64 Value)
|
|
{
|
|
b32 Result = ((Value.x >= Range.Min.x) && (Value.y >= Range.Min.y) &&
|
|
(Value.x <= Range.Max.x) && (Value.y <= Range.Max.y));
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s64 DimOfRange(range2_s64 Range)
|
|
{
|
|
v2_s64 Result = Range.Max - Range.Min;
|
|
return(Result);
|
|
}
|
|
|
|
inline range2_s64 Intersection(range2_s64 A, range2_s64 B)
|
|
{
|
|
range2_s64 Result = {Max(A.Min, B.Min), Min(A.Max, B.Max)};
|
|
return(Result);
|
|
}
|
|
|
|
inline v2_s64 CornerFromRange(range2_s64 Range, corner Corner)
|
|
{
|
|
v2_s64 Result = V2S64((Corner & (1 << Axis2_X))?Range.Min.x:Range.Max.x,
|
|
(Corner & (1 << Axis2_Y))?Range.Min.y:Range.Max.y);
|
|
return(Result);
|
|
} |