102 lines
2.5 KiB
C
102 lines
2.5 KiB
C
#include "all.h"
|
|
|
|
fn bool xyzEq(XYZ a, XYZ b) {
|
|
return a.x == b.x &&
|
|
a.y == b.y &&
|
|
a.z == b.z;
|
|
}
|
|
|
|
fn Range1u64 range1u64Create(u64 min, u64 max) {
|
|
Range1u64 result = {
|
|
.min = min,
|
|
.max = max
|
|
};
|
|
if (result.min > result.max) {
|
|
result.max = min;
|
|
result.min = max;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
fn Range1u64 mRangeFromNIdxMCount(u64 n_idx, u64 n_count, u64 m_count) {
|
|
u64 main_idxes_per_lane = m_count / n_count;
|
|
u64 leftover_idxes_count = m_count - main_idxes_per_lane * n_count;
|
|
u64 leftover_idxes_before_this_lane_count = Min(n_idx, leftover_idxes_count);
|
|
u64 lane_base_idx = n_idx*main_idxes_per_lane + leftover_idxes_before_this_lane_count;
|
|
u64 lane_base_idx__clamped = Min(lane_base_idx, m_count);
|
|
u64 lane_opl_idx = lane_base_idx__clamped + main_idxes_per_lane + ((n_idx < leftover_idxes_count) ? 1 : 0);
|
|
u64 lane_opl_idx__clamped = Min(lane_opl_idx, m_count);
|
|
Range1u64 result = range1u64Create(lane_base_idx__clamped, lane_opl_idx__clamped);
|
|
return result;
|
|
}
|
|
|
|
void u32Swap(u32* a, u32* b) {
|
|
int t = *a;
|
|
*a = *b;
|
|
*b = t;
|
|
}
|
|
|
|
u32 u32ArrPartition(u32 arr[], u32 low, u32 high) {
|
|
u32 pivot = arr[high];
|
|
u32 i = low - 1;
|
|
|
|
for (u32 j = low; j < high; j++) {
|
|
if (arr[j] < pivot) {
|
|
i++;
|
|
u32Swap(&arr[i], &arr[j]);
|
|
}
|
|
}
|
|
u32Swap(&arr[i + 1], &arr[high]);
|
|
return i + 1;
|
|
}
|
|
|
|
fn void u32Quicksort(u32 arr[], u32 low, u32 high) {
|
|
if (low < high) {
|
|
u32 pi = u32ArrPartition(arr, low, high);
|
|
if (pi != 0) {
|
|
u32Quicksort(arr, low, pi - 1);
|
|
}
|
|
u32Quicksort(arr, pi + 1, high);
|
|
}
|
|
}
|
|
|
|
fn void u32ReverseArray(u32 arr[], u32 size) {
|
|
u32 start = 0;
|
|
u32 end = size - 1;
|
|
while (start < end) {
|
|
u32 temp = arr[start];
|
|
arr[start] = arr[end];
|
|
arr[end] = temp;
|
|
start++;
|
|
end--;
|
|
}
|
|
}
|
|
|
|
fn Vec2f32 vec2Add(Vec2 a, Vec2 b) {
|
|
Vec2f32 result = a;
|
|
result.x += b.x;
|
|
result.y += b.y;
|
|
return result;
|
|
}
|
|
|
|
fn Vec2f32 vec2Subtract(Vec2 a, Vec2 b) {
|
|
Vec2f32 result = a;
|
|
result.x -= b.x;
|
|
result.y -= b.y;
|
|
return result;
|
|
}
|
|
|
|
fn Vec2f32 vec2FromHexCube(Vec2 map_center, XYZ cube, f32 size, f32 border_thickness) {
|
|
f32 hex_height = SQRT_3 * size;
|
|
f32 hex_width = 2.0 * size;
|
|
f32 horiz_spacing = 0.75 * (hex_width - border_thickness);
|
|
f32 vert_spacing = (hex_height - border_thickness);
|
|
bool parity = cube.x & 1;
|
|
i32 use_y = cube.y * -1;
|
|
return (Vec2) {
|
|
.x = map_center.x + (cube.x * horiz_spacing),
|
|
.y = map_center.y + ((use_y + (f32)(cube.x + parity) / 2.0) * vert_spacing) - (parity ? 0.5*vert_spacing : 0),
|
|
};
|
|
}
|
|
|