MetzNet
/
roleplay
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
roleplay/client/src/main.c

1393 lines
40 KiB
C
Raw Blame History

#include "GLFW/glfw3.h"
#include <stdio.h>
#define CGLM_PRINT_PRECISION 10
#define CGLM_DEFINE_PRINTS 1
#include "ui.h"
#include "gpu.h"
#include "draw.h"
#include "hex.h"
#include "arpa/inet.h"
#include "vk_mem_alloc.h"
#include "vulkan/vk_enum_string_helper.h"
#include "vulkan/vulkan_core.h"
#include "pthread.h"
#include <math.h>
#include <stdlib.h>
typedef struct EditorContextStruct {
uint32_t selected_region;
uint32_t last_selected_region;
uint32_t last_clicked_region;
uint32_t last_clicked_hex;
uint32_t last_clicked_vertex;
} EditorContext;
typedef struct ClientContextStruct {
GLFWwindow* window;
RenderContext* render;
UIContext* ui;
HexContext* hex;
vec3 position;
vec3 velocity;
vec2 rotation;
int32_t key_spin[2];
vec2 cur_spin;
double distance;
int32_t zoom;
bool camera_mode;
float key_spin_speed;
float cur_spin_speed;
float zoom_speed;
float move_speed;
EditorContext editor;
} ClientContext;
void* network_thread(void* data) {
ClientContext* context = (ClientContext*)data;
(void)context;
return NULL;
}
uint32_t add_hex_region(ClientContext* context) {
HexRegion* region;
allocate_hex_region(0, 0, 0, context->hex->data.current_map, &region, context->hex, context->render);
for(uint32_t hex = 0; hex < REGION_HEX_COUNT; hex++) {
region->data.hexes[hex].color[0] = 0xFFFFFFFF;
region->data.hexes[hex].color[1] = 0xFFFFFFFF;
region->data.hexes[hex].color[2] = 0xFFFFFFFF;
region->data.hexes[hex].color[3] = 0xFFFFFFFF;
region->data.hexes[hex].color[4] = 0xFFFFFFFF;
region->data.hexes[hex].color[5] = 0xFFFFFFFF;
region->data.hexes[hex].color[6] = 0xFFFFFFFF;
region->data.hexes[hex].height[0] = 0;
region->data.hexes[hex].height[1] = 0;
region->data.hexes[hex].height[2] = 0;
region->data.hexes[hex].height[3] = 0;
region->data.hexes[hex].height[4] = 0;
region->data.hexes[hex].height[5] = 0;
}
set_hex_region(region, context->hex, context->render);
uint32_t i = 0;
for(; i < MAX_LOADED_REGIONS; i++) {
if(region == context->hex->regions[i]) {
break;
}
}
return i;
}
#define COLOR_PICK_CONTAINER_ID 0x03
void hsv_to_rgb(vec3 hsv, vec3 rgb) {
float C = hsv[1] * hsv[2];
float H = hsv[0]*6;
float X = C * (1 - fabs((H - 2 * floor( H / 2 )) - 1));
vec4 temp = {0, 0, 0, 0};
if(0 <= H && H <= 1) {
temp[0] = C;
temp[1] = X;
} else if(1 <= H && H <= 2) {
temp[0] = X;
temp[1] = C;
} else if(2 <= H && H <= 3) {
temp[1] = C;
temp[2] = X;
} else if(3 <= H && H <= 4) {
temp[1] = X;
temp[2] = C;
} else if(4 <= H && H <= 5) {
temp[0] = X;
temp[2] = C;
} else if(5 <= H && H <= 6) {
temp[0] = C;
temp[2] = X;
}
float m = hsv[2] - C;
rgb[0] = temp[0] + m;
rgb[1] = temp[1] + m;
rgb[2] = temp[2] + m;
}
void rgb_string_set(UIContext* ui, RenderContext* gpu, vec3 hsv) {
vec3 rgb;
hsv_to_rgb(hsv, rgb);
char temp[10];
snprintf(temp, 10, "#%02x%02x%02x",
(uint)(rgb[0]*255),
(uint)(rgb[1]*255),
(uint)(rgb[2]*255));
update_ui_string(temp, COLOR_PICK_CONTAINER_ID, 0, 0, ui, gpu);
}
void sv_square_pick(UIContext* ui, RenderContext* gpu, float s, float v) {
if(s < 0) s = 0;
if(s > 1) s = 1;
if(v < 0) v = 0;
if(v > 1) v = 1;
Container* container = context_container(COLOR_PICK_CONTAINER_ID, ui);
Layer* layer = &container->layers[0];
GPUDrawable* select_outline = &layer->drawables_buffer[3];
GPUDrawable* select = &layer->drawables_buffer[4];
select->pos[0] = s*130 - 2;
select->pos[1] = v*130 - 2;
select->color[0][1] = s;
select->color[0][2] = 1-v;
select->color[1][1] = s;
select->color[1][2] = 1-v;
select->color[2][1] = s;
select->color[2][2] = 1-v;
select->color[3][1] = s;
select->color[3][2] = 1-v;
select_outline->pos[0] = s*130 - 3;
select_outline->pos[1] = v*130 - 3;
add_transfers(
&select_outline->pos[0],
layer->drawables,
3*sizeof(GPUDrawable) + offsetof(GPUDrawable, pos),
1*sizeof(vec2),
gpu);
add_transfers(
&select->pos[0],
layer->drawables,
4*sizeof(GPUDrawable) + offsetof(GPUDrawable, pos),
1*sizeof(vec2),
gpu);
add_transfers(
&select->color[0],
layer->drawables,
4*sizeof(GPUDrawable) + offsetof(GPUDrawable, color),
4*sizeof(vec4),
gpu);
rgb_string_set(ui, gpu, select->color[0]);
}
void sv_square_button_callback(UIContext* ui, RenderContext* gpu, float x, float y, int button, int action, int mods) {
(void)mods;
(void)x;
if(action == GLFW_PRESS && button == GLFW_MOUSE_BUTTON_LEFT) {
set_active_element(COLOR_PICK_CONTAINER_ID, 0, 1, ui);
sv_square_pick(ui, gpu, x, y);
} else if(action == GLFW_RELEASE && button == GLFW_MOUSE_BUTTON_LEFT) {
clear_active_element(ui, gpu);
}
}
void sv_square_cursor_callback(UIContext* ui, RenderContext* gpu, float x, float y) {
if(ui->active_element == 1
&& ui->active_layer == 0
&& ui->active_container == COLOR_PICK_CONTAINER_ID) {
sv_square_pick(ui, gpu, x, y);
}
}
void hue_bar_set(UIContext* ui, RenderContext* gpu, float y) {
if(y < 0) y = 0;
if(y > 1) y = 1;
Container* container = context_container(COLOR_PICK_CONTAINER_ID, ui);
Layer* layer = &container->layers[0];
GPUDrawable* sv_square = &layer->drawables_buffer[1];
GPUDrawable* select = &layer->drawables_buffer[4];
sv_square->color[0][0] = y;
sv_square->color[1][0] = y;
sv_square->color[2][0] = y;
sv_square->color[3][0] = y;
select->color[0][0] = y;
select->color[1][0] = y;
select->color[2][0] = y;
select->color[3][0] = y;
add_transfers(
&sv_square->color[0],
layer->drawables,
1*sizeof(GPUDrawable) + offsetof(GPUDrawable, color),
4*sizeof(vec4),
gpu);
add_transfers(
&select->color[0],
layer->drawables,
4*sizeof(GPUDrawable) + offsetof(GPUDrawable, color),
4*sizeof(vec4),
gpu);
rgb_string_set(ui, gpu, select->color[0]);
}
void hue_bar_scroll_callback(UIContext* ui, RenderContext* gpu, double x, double y) {
(void)x;
Container* container = context_container(COLOR_PICK_CONTAINER_ID, ui);
hue_bar_set(ui, gpu, y*0.01 + container->layers[0].drawables_buffer[1].color[0][0]);
}
void hue_bar_cursor_callback(UIContext* ui, RenderContext* gpu, float x, float y) {
(void)x;
if(ui->active_element == 2
&& ui->active_layer == 0
&& ui->active_container == COLOR_PICK_CONTAINER_ID) {
hue_bar_set(ui, gpu, y);
}
}
void hue_bar_button_callback(UIContext* ui, RenderContext* gpu, float x, float y, int button, int action, int mods) {
(void)mods;
(void)x;
if(action == GLFW_PRESS && button == GLFW_MOUSE_BUTTON_LEFT) {
set_active_element(COLOR_PICK_CONTAINER_ID, 0, 2, ui);
hue_bar_set(ui, gpu, y);
} else if(action == GLFW_RELEASE && button == GLFW_MOUSE_BUTTON_LEFT) {
clear_active_element(ui, gpu);
}
}
void hex_string_set_color(UIContext* ui, RenderContext* gpu, float color) {
Container* container = context_container(COLOR_PICK_CONTAINER_ID, ui);
container->layers[0].drawables_buffer[5].color[0][2] = color;
container->layers[0].drawables_buffer[5].color[0][3] = color;
container->layers[0].drawables_buffer[5].color[1][2] = color;
container->layers[0].drawables_buffer[5].color[1][3] = color;
container->layers[0].drawables_buffer[5].color[2][2] = color;
container->layers[0].drawables_buffer[5].color[2][3] = color;
container->layers[0].drawables_buffer[5].color[3][2] = color;
container->layers[0].drawables_buffer[5].color[3][3] = color;
add_transfers(
&container->layers[0].drawables_buffer[5].color[0],
container->layers[0].drawables,
5*sizeof(GPUDrawable) + offsetof(GPUDrawable, color),
4*sizeof(vec4),
gpu);
}
bool hex_string_key_callback(UIContext* ui, RenderContext* gpu, int key, int action, int mods) {
(void)mods;
if(action == GLFW_PRESS && key == GLFW_KEY_ESCAPE) {
clear_active_element(ui, gpu);
return true;
}
return false;
}
void hex_string_button_callback(UIContext* ui, RenderContext* gpu, float x, float y, int button, int action, int mods) {
(void)mods;
(void)x;
(void)y;
if(action == GLFW_PRESS && button == GLFW_MOUSE_BUTTON_LEFT) {
set_active_element(COLOR_PICK_CONTAINER_ID, 0, 5, ui);
hex_string_set_color(ui, gpu, 1);
}
}
void hex_string_deselect_callback(UIContext* ui, RenderContext* gpu) {
hex_string_set_color(ui, gpu, 0);
}
VkResult color_ui(ClientContext* context) {
GPUString strings[] = {
{
.pos = {2, 150},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 0,
.length = 9,
.font = 0,
},
};
GPUDrawable drawables[] = {
{
.pos = {0, 0},
.size = {190, 150},
.color = {{0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}},
},
{
.type = DRAWABLE_TYPE_RECT_HSV,
.pos = {2, 2},
.size = {130, 130},
.color = {{0, 0, 1, 1}, {0, 1, 1, 1}, {0, 0, 0, 1}, {0, 1, 0, 1}},
.events = UI_EVENT_BUTTON,
},
{
.type = DRAWABLE_TYPE_RECT_HSV,
.pos = {134, 2},
.size = {10, 130},
.color = {{0, 1, 1, 1}, {0, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
.events = UI_EVENT_BUTTON | UI_EVENT_SCROLL,
},
{
.pos = {9, 9},
.size = {7, 7},
.color = {{0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}},
},
{
.type = DRAWABLE_TYPE_RECT_HSV,
.pos = {10, 10},
.size = {5, 5},
.color = {{1, 0, 0, 1}, {1, 0, 0, 1}, {1, 0, 0, 1}, {1, 0, 0, 1}},
},
{
.pos = {20, 134},
.size = {95, 15},
.events = UI_EVENT_BUTTON | UI_EVENT_CURSOR,
},
{
.pos = {146, 2},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {168, 2},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {146, 24},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {168, 24},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {146, 46},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {168, 46},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {146, 68},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {168, 68},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {146, 90},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {168, 90},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {146, 112},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
{
.pos = {168, 112},
.size = {20, 20},
.color = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
},
};
uint32_t codes[9];
VkResult result;
VK_RESULT(map_string("#00000000", codes, 0, 0, context->ui));
LayerInput layer = {
.strings = strings,
.num_strings = sizeof(strings)/sizeof(GPUString),
.codes = codes,
.num_codes = sizeof(codes)/sizeof(uint32_t),
.drawables = drawables,
.num_drawables = sizeof(drawables)/sizeof(GPUDrawable),
};
UICallbacks callbacks[] = {
{
.layer = 0,
.element = 1,
.button = sv_square_button_callback,
.cursor = sv_square_cursor_callback,
},
{
.layer = 0,
.element = 2,
.button = hue_bar_button_callback,
.cursor = hue_bar_cursor_callback,
.scroll = hue_bar_scroll_callback,
},
{
.layer = 0,
.element = 5,
.button = hex_string_button_callback,
.key = hex_string_key_callback,
.deselect = hex_string_deselect_callback,
},
};
ContainerInput container = {
.layers = &layer,
.layer_count = 1,
.anchor = ANCHOR_BOTTOM_LEFT,
.id = COLOR_PICK_CONTAINER_ID,
.offset = {0, 0},
.size = {190, 150},
.callbacks = callbacks,
.callback_count = sizeof(callbacks)/sizeof(UICallbacks),
};
return create_container(&container, context->render, context->ui);
}
VkResult hex_info_ui(ClientContext* context) {
GPUString strings[] = {
{
.pos = {0, 33},
.color = {1, 1, 1, 1},
.size = 32,
.offset = 0,
.length = 0,
.font = 0,
},
{
.pos = {2, 50},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 20,
.length = 0,
.font = 0,
},
{
.pos = {2, 73},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 40,
.length = 0,
.font = 0,
},
{
.pos = {2, 93},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 60,
.length = 0,
.font = 0,
},
{
.pos = {2, 113},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 80,
.length = 0,
.font = 0,
},
{
.pos = {2, 133},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 100,
.length = 0,
.font = 0,
},
{
.pos = {2, 153},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 120,
.length = 0,
.font = 0,
},
{
.pos = {2, 173},
.color = {1, 1, 1, 1},
.size = 16,
.offset = 140,
.length = 0,
.font = 0,
},
};
GPUDrawable drawables[] = {
{
.pos = {0, 0},
.size = {150, 175},
.color = {{0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}},
},
};
LayerInput layer = {
.strings = strings,
.num_strings = sizeof(strings)/sizeof(GPUString),
.max_strings = sizeof(strings)/sizeof(GPUString) + 4,
.max_codes = 200,
.drawables = drawables,
.num_drawables = sizeof(drawables)/sizeof(GPUDrawable),
};
ContainerInput container = {
.id = 0x02,
.size = {150, 175},
.offset = {0, 0},
.anchor = ANCHOR_BOTTOM_RIGHT,
.layers = &layer,
.layer_count = 1,
};
return create_container(&container, context->render, context->ui);
}
VkResult region_info_ui(ClientContext* context) {
GPUString strings[] = {
{
.pos = {0, 33},
.color = {1, 1, 1, 1},
.size = 32,
.offset = 0,
.length = 0,
.font = 0,
},
{
.pos = {0, 33 + 1*40},
.color = {1, 1, 1, 1},
.size = 32,
.offset = 11,
.length = 0,
.font = 0,
},
{
.pos = {0, 33 + 2*40},
.color = {1, 1, 1, 1},
.size = 32,
.offset = 18,
.length = 0,
.font = 0,
},
{
.pos = {0, 33 + 3*40},
.color = {1, 1, 1, 1},
.size = 32,
.offset = 25,
.length = 0,
.font = 0,
},
};
GPUDrawable drawables[] = {
{
.pos = {0, 0},
.size = {225, 155},
.color = {{0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}, {0.4, 0.4, 0.4, 0.4}},
},
};
LayerInput layer = {
.strings = strings,
.num_strings = sizeof(strings)/sizeof(GPUString),
.max_strings = sizeof(strings)/sizeof(GPUString) + 4,
.max_codes = 100,
.drawables = drawables,
.num_drawables = sizeof(drawables)/sizeof(GPUDrawable),
};
ContainerInput container = {
.id = 0x01,
.size = {225, 155},
.offset = {0, 0},
.anchor = ANCHOR_TOP_RIGHT,
.layers = &layer,
.layer_count = 1,
};
return create_container(&container, context->render, context->ui);
}
VkResult update_region_info_ui(ClientContext* context) {
char temp[20];
VkResult result;
HexRegion* selected_region = context->hex->regions[context->editor.selected_region];
snprintf(temp,
sizeof(temp),
"Region %4d", context->editor.selected_region);
VK_RESULT(update_ui_string(temp, 0x01, 0, 0, context->ui, context->render));
if(selected_region == NULL) {
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x01, 0, 1, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x01, 0, 2, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x01, 0, 3, context->ui, context->render));
} else {
snprintf(
temp,
sizeof(temp),
"Q: %4d", selected_region->data.q);
VK_RESULT(update_ui_string(temp, 0x01, 0, 1, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"R: %4d", selected_region->data.r);
VK_RESULT(update_ui_string(temp, 0x01, 0, 2, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"Y: %4d", selected_region->data.y);
VK_RESULT(update_ui_string(temp, 0x01, 0, 3, context->ui, context->render));
}
return VK_SUCCESS;
}
VkResult update_hex_info_ui(ClientContext* context) {
char temp[20];
VkResult result;
HexRegion* region = context->hex->regions[context->hex->data.clicked_region];
if(region == NULL) {
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 0, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 1, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 2, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 3, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 4, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 5, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 6, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"");
VK_RESULT(update_ui_string(temp, 0x02, 0, 7, context->ui, context->render));
} else {
GPUHex* hex = &region->data.hexes[context->hex->data.clicked_hex];
snprintf(temp,
sizeof(temp),
"%d-%d",
context->hex->data.clicked_region,
context->hex->data.clicked_hex);
VK_RESULT(update_ui_string(temp, 0x02, 0, 0, context->ui, context->render));
int32_t hex_index = context->hex->data.clicked_hex;
float radius = 0;
float ring = 0;
int side = 0;
if(hex_index != 0) {
radius = floor(0.5 + sqrt(12*hex_index-3)/6);
ring = hex_index - (3*radius*radius - 3*radius + 1);
side = floor(ring/radius);
}
// TODO: fix, these are wrong lmao
int32_t hex_q = hex_starts_qr[side][0]*radius + hex_directions_qr[side][0]*(ring-(radius*side));
int32_t hex_r = hex_starts_qr[side][1]*radius + hex_directions_qr[side][1]*(ring-(radius*side));
int32_t world_q = hex_q + region->data.q*(REGION_SIZE*2 + 1) + region->data.r*REGION_SIZE;
int32_t world_r = hex_r + region->data.q*(REGION_SIZE + 0.5) + region->data.r*(REGION_SIZE*2+1);
snprintf(
temp,
sizeof(temp),
"%d, %d, %d, %d",
world_q,
world_r,
region->data.y,
context->hex->data.clicked_vertex);
VK_RESULT(update_ui_string(temp, 0x02, 0, 1, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"%02.02f %02.02f %02.02f",
hex->height[0], hex->height[1], hex->height[2]);
VK_RESULT(update_ui_string(temp, 0x02, 0, 2, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"%02.02f %02.02f %02.02f",
hex->height[3], hex->height[4], hex->height[5]);
VK_RESULT(update_ui_string(temp, 0x02, 0, 3, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"%08X",
hex->color[0]);
VK_RESULT(update_ui_string(temp, 0x02, 0, 4, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"%08X %08X",
hex->color[1], hex->color[2]);
VK_RESULT(update_ui_string(temp, 0x02, 0, 5, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"%08X %08X",
hex->color[3], hex->color[4]);
VK_RESULT(update_ui_string(temp, 0x02, 0, 6, context->ui, context->render));
snprintf(
temp,
sizeof(temp),
"%08X %08X",
hex->color[5], hex->color[6]);
VK_RESULT(update_ui_string(temp, 0x02, 0, 7, context->ui, context->render));
}
return VK_SUCCESS;
}
VkResult main_thread(ClientContext* context) {
VkResult result;
VK_RESULT(region_info_ui(context));
VK_RESULT(hex_info_ui(context));
VK_RESULT(color_ui(context));
//
double last_frame_time = 0;
while(glfwWindowShouldClose(context->window) == 0) {
double frame_time = glfwGetTime();
double delta_time = (frame_time - last_frame_time);
// Reset callback variables
context->zoom = 0;
context->cur_spin[0] = 0;
context->cur_spin[1] = 0;
glfwPollEvents();
if(context->editor.last_clicked_region != context->hex->data.clicked_region ||
context->editor.last_clicked_hex != context->hex->data.clicked_hex ||
context->editor.last_clicked_vertex != context->hex->data.clicked_vertex) {
context->editor.last_clicked_region = context->hex->data.clicked_region;
context->editor.last_clicked_hex = context->hex->data.clicked_hex;
context->editor.last_clicked_vertex = context->hex->data.clicked_vertex;
update_hex_info_ui(context);
}
if(context->editor.selected_region != context->editor.last_selected_region) {
context->editor.last_selected_region = context->editor.selected_region;
update_region_info_ui(context);
}
if((context->key_spin[0] != 0 || context->key_spin[1] != 0 ||
context->velocity[0] != 0 || context->velocity[1] != 0 || context->velocity[2] != 0 ||
context->zoom != 0 ||
context->cur_spin[0] != 0 || context->cur_spin[1] != 0 ||
context->render->framebuffer_recreated == true)) {
if(context->render->framebuffer_recreated == true) {
context->render->framebuffer_recreated = false;
VK_RESULT(update_hex_proj(context->render, context->hex));
VK_RESULT(update_ui_context_resolution(context->ui, context->render));
}
context->rotation[0] += (float)context->key_spin[0]*delta_time*context->key_spin_speed;
context->rotation[0] += (float)context->cur_spin[0]*delta_time*context->cur_spin_speed;
if(context->rotation[0] > 2*M_PI) {
context->rotation[0] -= 2*M_PI;
} else if(context->rotation[0] < 0) {
context->rotation[0] += 2*M_PI;
}
context->rotation[1] += (float)context->key_spin[1]*delta_time*context->key_spin_speed;
context->rotation[1] += (float)context->cur_spin[1]*delta_time*context->cur_spin_speed;
if(context->rotation[1] > (M_PI/2 - 0.1)) {
context->rotation[1] = (M_PI/2 - 0.1);
} else if(context->rotation[1] < 0) {
context->rotation[1] = 0;
}
context->position[0] += - context->velocity[2]*context->move_speed*cos(context->rotation[0])
- context->velocity[0]*context->move_speed*sin(context->rotation[0]);
context->position[2] += context->velocity[0]*context->move_speed*cos(context->rotation[0])
- context->velocity[2]*context->move_speed*sin(context->rotation[0]);
context->position[1] += context->velocity[1]*context->move_speed;
context->distance += context->zoom*delta_time*context->zoom_speed;
if(context->distance < 1) {
context->distance = 1;
}
VK_RESULT(update_hex_view(
context->position,
context->rotation,
context->distance,
context->render,
context->hex));
}
//
VkResult result = draw_frame(context->render, context->ui, context->hex, frame_time);
if(result != VK_SUCCESS) {
fprintf(stderr, "draw_frame error: %s\n", string_VkResult(result));
glfwDestroyWindow(context->window);
}
last_frame_time = frame_time;
}
return 0;
}
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
(void)scancode;
(void)mods;
ClientContext* context = (ClientContext*)glfwGetWindowUserPointer(window);
if(context->ui->active_callbacks != NULL && context->ui->active_callbacks->key != NULL) {
if(context->ui->active_callbacks->key(context->ui, context->render, key, action, mods)) {
return;
}
}
switch(key) {
case GLFW_KEY_A:
if(action == GLFW_PRESS) {
context->key_spin[0] -= 1;
} else if(action == GLFW_RELEASE) {
context->key_spin[0] += 1;
}
break;
case GLFW_KEY_D:
if(action == GLFW_PRESS) {
context->key_spin[0] += 1;
} else if(action == GLFW_RELEASE) {
context->key_spin[0] -= 1;
}
break;
case GLFW_KEY_W:
if(action == GLFW_PRESS) {
context->key_spin[1] += 1;
} else if(action == GLFW_RELEASE) {
context->key_spin[1] -= 1;
}
break;
case GLFW_KEY_S:
if(action == GLFW_PRESS) {
context->key_spin[1] -= 1;
} else if(action == GLFW_RELEASE) {
context->key_spin[1] += 1;
}
break;
case GLFW_KEY_UP:
if(action == GLFW_PRESS) {
context->velocity[2] += 1;
} else if(action == GLFW_RELEASE) {
context->velocity[2] -= 1;
}
break;
case GLFW_KEY_DOWN:
if(action == GLFW_PRESS) {
context->velocity[2] -= 1;
} else if(action == GLFW_RELEASE) {
context->velocity[2] += 1;
}
break;
case GLFW_KEY_LEFT:
if(action == GLFW_PRESS) {
context->velocity[0] -= 1;
} else if(action == GLFW_RELEASE) {
context->velocity[0] += 1;
}
break;
case GLFW_KEY_RIGHT:
if(action == GLFW_PRESS) {
context->velocity[0] += 1;
} else if(action == GLFW_RELEASE) {
context->velocity[0] -= 1;
}
break;
case GLFW_KEY_LEFT_SHIFT:
if(action == GLFW_PRESS) {
context->velocity[1] -= 1;
} else if(action == GLFW_RELEASE) {
context->velocity[1] += 1;
}
break;
case GLFW_KEY_SPACE:
if(action == GLFW_PRESS) {
context->velocity[1] += 1;
} else if(action == GLFW_RELEASE) {
context->velocity[1] -= 1;
}
break;
case GLFW_KEY_EQUAL:
if(action == GLFW_PRESS) {
context->editor.selected_region = add_hex_region(context);
}
break;
case GLFW_KEY_LEFT_BRACKET:
if(action == GLFW_PRESS) {
context->editor.selected_region -= 1;
if(context->editor.selected_region > MAX_LOADED_REGIONS) {
context->editor.selected_region = MAX_LOADED_REGIONS;
}
}
break;
case GLFW_KEY_RIGHT_BRACKET:
if(action == GLFW_PRESS) {
context->editor.selected_region += 1;
if(context->editor.selected_region > MAX_LOADED_REGIONS) {
context->editor.selected_region = 0;
}
}
break;
case GLFW_KEY_I:
if(action == GLFW_PRESS) {
if(context->hex->regions[context->editor.selected_region] != NULL) {
context->hex->regions[context->editor.selected_region]->data.q += 1;
add_transfer(
&context->hex->regions[context->editor.selected_region]->data.q,
context->hex->regions[context->editor.selected_region]->region,
offsetof(GPUHexRegion, q),
sizeof(uint32_t),
context->render->current_frame,
context->render);
}
update_region_info_ui(context);
}
break;
case GLFW_KEY_K:
if(action == GLFW_PRESS) {
if(context->hex->regions[context->editor.selected_region] != NULL) {
context->hex->regions[context->editor.selected_region]->data.q -= 1;
add_transfer(
&context->hex->regions[context->editor.selected_region]->data.q,
context->hex->regions[context->editor.selected_region]->region,
offsetof(GPUHexRegion, q),
sizeof(uint32_t),
context->render->current_frame,
context->render);
}
update_region_info_ui(context);
}
break;
case GLFW_KEY_J:
if(action == GLFW_PRESS) {
if(context->hex->regions[context->editor.selected_region] != NULL) {
context->hex->regions[context->editor.selected_region]->data.r += 1;
add_transfer(
&context->hex->regions[context->editor.selected_region]->data.r,
context->hex->regions[context->editor.selected_region]->region,
offsetof(GPUHexRegion, r),
sizeof(uint32_t),
context->render->current_frame,
context->render);
}
update_region_info_ui(context);
}
break;
case GLFW_KEY_L:
if(action == GLFW_PRESS) {
if(context->hex->regions[context->editor.selected_region] != NULL) {
context->hex->regions[context->editor.selected_region]->data.r -= 1;
add_transfer(
&context->hex->regions[context->editor.selected_region]->data.r,
context->hex->regions[context->editor.selected_region]->region,
offsetof(GPUHexRegion, r),
sizeof(uint32_t),
context->render->current_frame,
context->render);
}
update_region_info_ui(context);
}
break;
case GLFW_KEY_O:
if(action == GLFW_PRESS) {
if(context->hex->regions[context->editor.selected_region] != NULL) {
context->hex->regions[context->editor.selected_region]->data.y += 1;
add_transfer(
&context->hex->regions[context->editor.selected_region]->data.y,
context->hex->regions[context->editor.selected_region]->region,
offsetof(GPUHexRegion, y),
sizeof(int32_t),
context->render->current_frame,
context->render);
}
update_region_info_ui(context);
}
break;
case GLFW_KEY_U:
if(action == GLFW_PRESS) {
if(context->hex->regions[context->editor.selected_region] != NULL) {
context->hex->regions[context->editor.selected_region]->data.y -= 1;
add_transfer(
&context->hex->regions[context->editor.selected_region]->data.y,
context->hex->regions[context->editor.selected_region]->region,
offsetof(GPUHexRegion, y),
sizeof(int32_t),
context->render->current_frame,
context->render);
}
update_region_info_ui(context);
}
break;
case GLFW_KEY_Y:
if(action == GLFW_PRESS) {
HexRegion* region = context->hex->regions[context->hex->data.clicked_region];
if(region != NULL) {
region->data.hexes[context->hex->data.clicked_hex].height[context->hex->data.clicked_vertex-1] += 0.1;
add_transfer(
&region->data.hexes[context->hex->data.clicked_hex].height[context->hex->data.clicked_vertex-1],
region->region,
offsetof(GPUHexRegion, hexes)
+ sizeof(GPUHex)*context->hex->data.clicked_hex
+ offsetof(GPUHex, height)
+ sizeof(float)*(context->hex->data.clicked_vertex-1),
sizeof(float),
context->render->current_frame,
context->render);
update_hex_info_ui(context);
}
}
break;
case GLFW_KEY_H:
if(action == GLFW_PRESS) {
HexRegion* region = context->hex->regions[context->hex->data.clicked_region];
if(region != NULL) {
region->data.hexes[context->hex->data.clicked_hex].height[context->hex->data.clicked_vertex-1] -= 0.1;
add_transfer(
&region->data.hexes[context->hex->data.clicked_hex].height[context->hex->data.clicked_vertex-1],
region->region,
offsetof(GPUHexRegion, hexes)
+ sizeof(GPUHex)*context->hex->data.clicked_hex
+ offsetof(GPUHex, height)
+ sizeof(float)*(context->hex->data.clicked_vertex-1),
sizeof(float),
context->render->current_frame,
context->render);
update_hex_info_ui(context);
}
}
break;
}
}
void button_callback(GLFWwindow* window, int button, int action, int mods) {
double cursor[2];
uint32_t container;
uint32_t layer;
uint32_t element;
vec2 position;
ClientContext* context = (ClientContext*)glfwGetWindowUserPointer(window);
glfwGetCursorPos(window, &cursor[0], &cursor[1]);
if(context->ui->active_callbacks != NULL && context->ui->active_callbacks->button != NULL) {
Container* container_ptr = context_container(context->ui->active_container, context->ui);
GPUDrawable* drawable_ptr = &container_ptr->layers[context->ui->active_layer].drawables_buffer[context->ui->active_element];
vec2 element_pos = {
drawable_ptr->pos[0] + container_ptr->data.offset[0],
drawable_ptr->pos[1] + container_ptr->data.offset[1],
};
anchor_offset(context->render, container_ptr, element_pos);
vec2 element_size = {
drawable_ptr->size[0],
drawable_ptr->size[1],
};
vec2 point = {
(cursor[0] - element_pos[0])/element_size[0],
(cursor[1] - element_pos[1])/element_size[1],
};
if(point[0] <= 1 && point[0] >= 0 && point[1] <= 1 && point[1] >= 0) {
context->ui->active_callbacks->button(
context->ui,
context->render,
point[0],
point[1],
button,
action,
mods);
return;
} else {
clear_active_element(context->ui, context->render);
}
}
if(ui_intersect(cursor, context->render, context->ui, UI_EVENT_BUTTON, &container, &layer, &element, position)) {
Container* container_ptr = context_container(container, context->ui);
for(uint32_t c = 0; c < container_ptr->callback_count; c++) {
if(container_ptr->callbacks[c].element == element) {
if(container_ptr->callbacks[c].button != NULL) {
container_ptr->callbacks[c].button(context->ui, context->render, position[0], position[1], button, action, mods);
}
break;
}
}
} else {
}
update_hex_click(cursor, context->hex, context->render);
if(button == GLFW_MOUSE_BUTTON_MIDDLE) {
if(action == GLFW_PRESS) {
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
context->camera_mode = true;
} else {
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
context->camera_mode = false;
}
}
}
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
(void)xoffset;
uint32_t container;
uint32_t layer;
uint32_t element;
vec2 position;
ClientContext* context = (ClientContext*)glfwGetWindowUserPointer(window);
if(context->ui->active_callbacks != NULL && context->ui->active_callbacks->scroll != NULL) {
context->ui->active_callbacks->scroll(context->ui, context->render, xoffset, yoffset);
} else if(ui_intersect(
context->ui->cursor,
context->render,
context->ui,
UI_EVENT_SCROLL,
&container,
&layer,
&element,
position)) {
Container* container_ptr = context_container(container, context->ui);
for(uint32_t c = 0; c < container_ptr->callback_count; c++) {
if(container_ptr->callbacks[c].element == element) {
if(container_ptr->callbacks[c].scroll != NULL) {
container_ptr->callbacks[c].scroll(context->ui, context->render, xoffset, yoffset);
}
break;
}
}
} else {
context->zoom = -yoffset;
}
}
void cursor_callback(GLFWwindow* window, double xpos, double ypos) {
ClientContext* context = (ClientContext*)glfwGetWindowUserPointer(window);
uint32_t container;
uint32_t element;
uint32_t layer;
vec2 position;
vec2 last_cursor = {
context->ui->cursor[0],
context->ui->cursor[1],
};
context->ui->cursor[0] = xpos;
context->ui->cursor[1] = ypos;
if(context->camera_mode == true) {
context->cur_spin[0] = (xpos - last_cursor[0])/context->render->swapchain_extent.width*-100;
context->cur_spin[1] = (ypos - last_cursor[1])/context->render->swapchain_extent.height*100;
} else {
if(context->ui->active_callbacks != NULL && context->ui->active_callbacks->cursor != NULL) {
Container* container_ptr = context_container(context->ui->active_container, context->ui);
GPUDrawable* drawable_ptr = &container_ptr->layers[context->ui->active_layer].drawables_buffer[context->ui->active_element];
vec2 element_pos = {
drawable_ptr->pos[0] + container_ptr->data.offset[0],
drawable_ptr->pos[1] + container_ptr->data.offset[1],
};
anchor_offset(context->render, container_ptr, element_pos);
vec2 element_size = {
drawable_ptr->size[0],
drawable_ptr->size[1],
};
context->ui->active_callbacks->cursor(
context->ui,
context->render,
(context->ui->cursor[0] - element_pos[0])/element_size[0],
(context->ui->cursor[1] - element_pos[1])/element_size[1]);
} else if(ui_intersect(context->ui->cursor, context->render, context->ui, UI_EVENT_CURSOR, &container, &layer, &element, position)) {
Container* container_ptr = context_container(container, context->ui);
for(uint32_t c = 0; c < container_ptr->callback_count; c++) {
if(container_ptr->callbacks[c].element == element) {
if(container_ptr->callbacks[c].cursor != NULL) {
container_ptr->callbacks[c].cursor(context->ui, context->render, position[0], position[1]);
}
break;
}
}
} else {
update_hex_hover(context->ui->cursor, context->hex, context->render);
}
}
}
int main() {
ClientContext context = {
.render = malloc(sizeof(RenderContext)),
.ui = malloc(sizeof(UIContext)),
.hex = malloc(sizeof(HexContext)),
.window = init_window(),
.position = {0, 0, 0},
.rotation = {3*M_PI/2, M_PI/4},
.distance = 25,
.key_spin_speed = 1.0,
.cur_spin_speed = 1.0,
.zoom_speed = 1.0,
.move_speed = 0.1,
.editor = {
.selected_region = MAX_LOADED_REGIONS,
.last_selected_region = 0,
.last_clicked_region = MAX_LOADED_REGIONS,
},
};
if(context.window == NULL || context.render == NULL || context.ui == NULL || context.hex == NULL) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memset(context.render, 0, sizeof(RenderContext));
memset(context.ui, 0, sizeof(UIContext));
memset(context.hex, 0, sizeof(HexContext));
glfwSetWindowUserPointer(context.window, &context);
glfwSetKeyCallback(context.window, key_callback);
glfwSetMouseButtonCallback(context.window, button_callback);
glfwSetScrollCallback(context.window, scroll_callback);
glfwSetCursorPosCallback(context.window, cursor_callback);
int error;
VkResult result;
VK_RESULT(init_vulkan(context.window, context.render));
// TODO: make # of fonts/textures/containers scaling, recreate GPU buffers as necessary
VK_RESULT(create_ui_context(10, 10, 10, context.render, context.ui));
VK_RESULT(create_hex_context(context.render, context.hex));
pthread_t network_thread_handle;
error = pthread_create(&network_thread_handle, NULL, &network_thread, &context);
if(error != 0) {
return error;
}
error = main_thread(&context);
if(error != 0) {
return error;
}
error = pthread_join(network_thread_handle, NULL);
if(error != 0) {
return error;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink