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

799 lines
33 KiB
C
Raw Blame History

#include <stdio.h>
#include "hex.h"
#include "engine.h"
#include "editor.h"
#include "events.h"
#include "ui_lua.h"
#include "editor_lua.h"
#include "vulkan/vulkan_core.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define SELECTION_HIGHLIGHT_OFFSET 0.05f
#define SELECTION_POINT_SIZE 12.0f
#define SELECTION_POINT_OFFSET 0.05f
// Hover preview uses the last (reserved) highlight/point slot, a slightly
// higher offset so it never z-fights with a selected element underneath,
// and a translucent color that switches between "would add" and "would
// remove" depending on whether the hovered element is already selected.
#define HOVER_HIGHLIGHT_OFFSET 0.07f
#define HOVER_POINT_SIZE 16.0f
#define HOVER_POINT_OFFSET 0.07f
#define HOVER_ADD_COLOR {0.2f, 0.85f, 1.0f, 0.45f}
#define HOVER_REMOVE_COLOR {1.0f, 0.2f, 0.2f, 0.55f}
const char* ModeStrings[] = {
"None",
"Vertex",
"Neighbor",
"Hex",
"Region",
};
uint32_t hex_color(vec4 color) {
return ((lrint(color[0]*255.0) & 0xFF) << 24)
+ ((lrint(color[1]*255.0) & 0xFF) << 16)
+ ((lrint(color[2]*255.0) & 0xFF) << 8)
+ ((lrint(color[3]*255.0) & 0xFF) << 0);
}
VkResult set_vertex_height(float height, uint32_t region, uint32_t hex, uint32_t vertex, ClientContext* context) {
if(vertex == 0) return VK_ERROR_VALIDATION_FAILED_EXT;
context->hex.regions[region]->data.hexes[hex].height[vertex-1] = height;
return add_transfer(
&context->hex.regions[region]->data.hexes[hex].height[vertex-1],
context->hex.regions[region]->region,
offsetof(GPUHexRegion, hexes)
+ sizeof(GPUHex)*hex
+ offsetof(GPUHex, height)
+ sizeof(float)*(vertex-1),
sizeof(float),
context->render.current_frame,
&context->render);
}
// vertex is 1-6 (the hex's 6 outer corners - matches height[]'s indexing).
VkResult set_vertex_color(vec4 color, uint32_t region, uint32_t hex, uint32_t vertex, ClientContext* context) {
context->hex.regions[region]->data.hexes[hex].outer_colors[vertex-1] = hex_color(color);
return add_transfer(
&context->hex.regions[region]->data.hexes[hex].outer_colors[vertex-1],
context->hex.regions[region]->region,
offsetof(GPUHexRegion, hexes)
+ sizeof(GPUHex)*hex
+ offsetof(GPUHex, outer_colors)
+ sizeof(uint32_t)*(vertex-1),
sizeof(uint32_t),
context->render.current_frame,
&context->render);
}
// triangle is 0-5 (one of the hex's 6 wedges - see hex.vert's `wedge`).
VkResult set_hex_triangle_color(vec4 color, uint32_t region, uint32_t hex, uint32_t triangle, ClientContext* context) {
context->hex.regions[region]->data.hexes[hex].inner_colors[triangle] = hex_color(color);
return add_transfer(
&context->hex.regions[region]->data.hexes[hex].inner_colors[triangle],
context->hex.regions[region]->region,
offsetof(GPUHexRegion, hexes)
+ sizeof(GPUHex)*hex
+ offsetof(GPUHex, inner_colors)
+ sizeof(uint32_t)*triangle,
sizeof(uint32_t),
context->render.current_frame,
&context->render);
}
// Sets (rather than toggles) wedge `triangle`'s flat bit, so callers that
// already know the target state (editor_selection_toggle_flat) don't need
// a read-modify-write of their own on top of this one.
VkResult set_hex_flat(bool flat, uint32_t region, uint32_t hex, uint32_t triangle, ClientContext* context) {
uint32_t* mask = &context->hex.regions[region]->data.hexes[hex].flat_mask;
if(flat) *mask |= (1u << triangle);
else *mask &= ~(1u << triangle);
return add_transfer(
mask,
context->hex.regions[region]->region,
offsetof(GPUHexRegion, hexes)
+ sizeof(GPUHex)*hex
+ offsetof(GPUHex, flat_mask),
sizeof(uint32_t),
context->render.current_frame,
&context->render);
}
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].inner_colors[0] = 0xFFFFFFFF;
region->data.hexes[hex].inner_colors[1] = 0xFFFFFFFF;
region->data.hexes[hex].inner_colors[2] = 0xFFFFFFFF;
region->data.hexes[hex].inner_colors[3] = 0xFFFFFFFF;
region->data.hexes[hex].inner_colors[4] = 0xFFFFFFFF;
region->data.hexes[hex].inner_colors[5] = 0xFFFFFFFF;
region->data.hexes[hex].outer_colors[0] = 0xFFFFFFFF;
region->data.hexes[hex].outer_colors[1] = 0xFFFFFFFF;
region->data.hexes[hex].outer_colors[2] = 0xFFFFFFFF;
region->data.hexes[hex].outer_colors[3] = 0xFFFFFFFF;
region->data.hexes[hex].outer_colors[4] = 0xFFFFFFFF;
region->data.hexes[hex].outer_colors[5] = 0xFFFFFFFF;
region->data.hexes[hex].flat_mask = 0;
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;
}
// Movement/spin keys are only ever seen by editor.c when no UI element has
// focus (engine.c routes key events to the focused element first). If focus
// is gained while a key is held, its release never reaches us and the
// accumulator in move_cam/spin_cam is left stuck. Zeroing here every frame a
// UI element is focused keeps the camera from drifting forever in that case.
//
// Integrates the editor's WASD/scroll control scheme into the engine-owned
// context->camera. The orbital parameterization itself lives on Camera; this
// is just the policy of how held input maps to changes in it, so a scripted
// sequence or a different app could drive the same camera without any of
// this accumulator machinery.
void editor_frame_callback(ClientContext* context, double delta_time) {
EditorData* data = context->app_data;
Camera* camera = &context->camera;
// Which cameras/containers track the window size is app policy (engine.c
// only handles UI's own screen-space scale) - the main view is the one
// built-in camera, kept full-window in this pass (see
// cursor_to_world_ray's full-window assumption in hex.c).
if(context->render.framebuffer_recreated) {
data->main_container->data.size[0] = context->render.swapchain_extent.width / context->render.window_scale[0];
data->main_container->data.size[1] = context->render.swapchain_extent.height / context->render.window_scale[1];
add_transfers(
&data->main_container->data.size,
data->main_container->container,
offsetof(GPUContainer, size),
sizeof(vec2),
&context->render);
camera_update_proj(camera, (float)context->render.swapchain_extent.width/(float)context->render.swapchain_extent.height);
camera_sync_gpu(camera, &context->render);
update_hex_picking_inverse(camera, &context->hex);
}
if(context->ui.active_container != NULL) {
data->velocity[0] = 0;
data->velocity[1] = 0;
data->velocity[2] = 0;
data->spin[0] = 0;
data->spin[1] = 0;
}
if(data->spin[0] != 0 || data->spin[1] != 0 ||
data->velocity[0] != 0 || data->velocity[1] != 0 || data->velocity[2] != 0 ||
data->zoom != 0) {
camera->rotation[0] += (float)data->spin[0]*delta_time*data->spin_speed;
if(camera->rotation[0] > 2*M_PI) {
camera->rotation[0] -= 2*M_PI;
} else if(camera->rotation[0] < 0) {
camera->rotation[0] += 2*M_PI;
}
camera->rotation[1] += (float)data->spin[1]*delta_time*data->spin_speed;
if(camera->rotation[1] > (M_PI/2 - 0.1)) {
camera->rotation[1] = (M_PI/2 - 0.1);
} else if(camera->rotation[1] < 0) {
camera->rotation[1] = 0;
}
float move_x = data->velocity[0];
float move_z = data->velocity[2];
float move_mag = sqrt(move_x*move_x + move_z*move_z);
if(move_mag > 1) {
move_x /= move_mag;
move_z /= move_mag;
}
camera->position[0] += - move_z*data->move_speed*cos(camera->rotation[0])
- move_x*data->move_speed*sin(camera->rotation[0]);
camera->position[2] += move_x*data->move_speed*cos(camera->rotation[0])
- move_z*data->move_speed*sin(camera->rotation[0]);
camera->position[1] += data->velocity[1]*data->move_speed;
// data->zoom is a one-frame scroll impulse, not a held input like
// spin/velocity, so it isn't scaled by delta_time.
camera->distance += data->zoom*data->zoom_speed;
if(camera->distance < 1) {
camera->distance = 1;
}
camera_update_view(camera);
camera_sync_gpu(camera, &context->render);
update_hex_picking_inverse(camera, &context->hex);
}
// Consumed above; reset after (not at the top, where it would wipe this
// frame's scroll_callback input, which fires during glfwPollEvents,
// before this callback runs).
data->zoom = 0;
}
void editor_key_callback(ClientContext* context, int key, int action, int mods) {
EditorData* data = context->app_data;
EditorMode mode = current_mode(context);
for(uint32_t i = 0; i < data->mode_key_counts[mode]; i++) {
if(data->mode_keys[mode][i].key == key) {
data->mode_keys[mode][i].logic(data, context, &data->mode_keys[mode][i], action, mods);
return;
}
}
for(uint32_t i = 0; i < data->mode_key_counts[MODE_NONE]; i++) {
if(data->mode_keys[MODE_NONE][i].key == key) {
data->mode_keys[MODE_NONE][i].logic(data, context, &data->mode_keys[MODE_NONE][i], action, mods);
return;
}
}
}
void spin_cam_key(EditorData* data, ClientContext* context, ModeKey* binding, int action, int mods) {
(void)context;
(void)mods;
if(action == GLFW_PRESS) data->spin[binding->axis] += binding->amount;
else if(action == GLFW_RELEASE) data->spin[binding->axis] -= binding->amount;
}
void move_cam_key(EditorData* data, ClientContext* context, ModeKey* binding, int action, int mods) {
(void)context;
(void)mods;
if(action == GLFW_PRESS) data->velocity[binding->axis] += binding->amount;
else if(action == GLFW_RELEASE) data->velocity[binding->axis] -= binding->amount;
}
void editor_scroll_callback(ClientContext* context, double x, double y) {
(void)x;
EditorData* data = context->app_data;
data->zoom = (int32_t)y;
}
void resize_selected(EditorData* data, unsigned int size) {
uint32_t* new_regions = malloc(sizeof(uint32_t)*size);
uint32_t* new_hexes = malloc(sizeof(uint32_t)*size);
uint32_t* new_vertices = malloc(sizeof(uint32_t)*size);
if(data->selected_regions != NULL) {
memcpy(new_regions, data->selected_regions, data->selected_count*sizeof(uint32_t));
free(data->selected_regions);
}
if(data->selected_hexes != NULL) {
memcpy(new_hexes, data->selected_hexes, data->selected_count*sizeof(uint32_t));
free(data->selected_hexes);
}
if(data->selected_vertices != NULL) {
memcpy(new_vertices, data->selected_vertices, data->selected_count*sizeof(uint32_t));
free(data->selected_vertices);
}
data->selected_regions = new_regions;
data->selected_hexes = new_hexes;
data->selected_vertices = new_vertices;
data->selected_max = size;
}
int32_t find_selected_vertex(EditorData* data, uint32_t region, uint32_t hex, uint32_t vertex) {
for(uint32_t i = 0; i < data->selected_count; i++) {
if(data->selected_regions[i] == region
&& data->selected_hexes[i] == hex
&& data->selected_vertices[i] == vertex) {
return (int32_t)i;
}
}
return -1;
}
void add_selected(EditorData* data, uint32_t region, uint32_t hex, uint32_t vertex) {
if(data->selected_count >= data->selected_max) {
resize_selected(data, data->selected_max == 0 ? 1 : data->selected_max*2);
}
data->selected_regions[data->selected_count] = region;
data->selected_hexes[data->selected_count] = hex;
data->selected_vertices[data->selected_count] = vertex;
data->selected_count++;
}
void remove_selected_at(EditorData* data, uint32_t index) {
for(uint32_t i = index+1; i < data->selected_count; i++) {
data->selected_regions[i-1] = data->selected_regions[i];
data->selected_hexes[i-1] = data->selected_hexes[i];
data->selected_vertices[i-1] = data->selected_vertices[i];
}
data->selected_count--;
}
// Resolves (region, hex, vertex) plus up to 2 other hexes sharing that same
// world corner (a hex corner touches up to 3 hexes): hex_qr/region_qr/
// hex_add build the hex's absolute world coordinate, hex_vertex_neighbors
// finds the corner's other hexes in world coordinates, and
// first_matching_region resolves each back to a loaded region index (a
// neighbor that isn't loaded is skipped). Writes up to 3 entries (self
// first, then any loaded neighbors) into the out arrays and returns the
// count. Only meaningful for real vertex indices (1-6) - Hex-mode wedge
// selections are hex-local, so nothing calls this for those.
static uint32_t resolve_vertex_group(
ClientContext* context, uint32_t region, uint32_t hex, uint32_t vertex,
uint32_t out_region[3], uint32_t out_hex[3], uint32_t out_vertex[3]) {
out_region[0] = region;
out_hex[0] = hex;
out_vertex[0] = vertex;
uint32_t count = 1;
HexRegion* r = context->hex.regions[region];
HexCoord world;
region_qr(r->data.position, &world);
HexCoord hex_local;
hex_qr(hex, &hex_local);
hex_add(hex_local, &world);
uint32_t n_vertex[2];
HexCoord n_region_coord[2];
uint32_t n_hex[2];
hex_vertex_neighbors(vertex, world, n_vertex, n_region_coord, n_hex);
for(uint32_t i = 0; i < 2; i++) {
uint32_t actual_region;
first_matching_region(n_region_coord[i], r->data.y, &actual_region, &context->hex);
if(actual_region == MAX_LOADED_REGIONS) continue;
out_region[count] = actual_region;
out_hex[count] = n_hex[i];
out_vertex[count] = n_vertex[i];
count++;
}
return count;
}
// editor.set_color (editor_lua.c) - Vertex mode paints the selected corner
// and any loaded neighbors sharing it (so adjacent hexes stay seamless);
// Hex mode paints just the selected wedge's own inner color.
void editor_selection_set_color(ClientContext* context, vec4 color) {
EditorData* data = context->app_data;
EditorMode mode = current_mode(context);
for(uint32_t i = 0; i < data->selected_count; i++) {
if(mode == MODE_VERTEX) {
uint32_t g_region[3], g_hex[3], g_vertex[3];
uint32_t count = resolve_vertex_group(
context, data->selected_regions[i], data->selected_hexes[i], data->selected_vertices[i],
g_region, g_hex, g_vertex);
for(uint32_t g = 0; g < count; g++) {
set_vertex_color(color, g_region[g], g_hex[g], g_vertex[g], context);
}
} else if(mode == MODE_HEX) {
set_hex_triangle_color(color, data->selected_regions[i], data->selected_hexes[i], data->selected_vertices[i], context);
}
}
}
// editor.nudge_height (editor_lua.c) - Vertex mode only; a wedge index
// (Hex mode) isn't a valid height-vertex index, so this no-ops there.
void editor_selection_nudge_height(ClientContext* context, float delta) {
EditorData* data = context->app_data;
if(current_mode(context) != MODE_VERTEX) return;
for(uint32_t i = 0; i < data->selected_count; i++) {
uint32_t g_region[3], g_hex[3], g_vertex[3];
uint32_t count = resolve_vertex_group(
context, data->selected_regions[i], data->selected_hexes[i], data->selected_vertices[i],
g_region, g_hex, g_vertex);
for(uint32_t g = 0; g < count; g++) {
float height = context->hex.regions[g_region[g]]->data.hexes[g_hex[g]].height[g_vertex[g]-1];
set_vertex_height(height + delta, g_region[g], g_hex[g], g_vertex[g], context);
}
}
}
// editor.toggle_flat (editor_lua.c) - Hex mode only; flips each selected
// wedge's own flat bit independently (no neighbor concept - inner colors
// and flat_mask are hex-local, unlike outer_colors/height).
void editor_selection_toggle_flat(ClientContext* context) {
EditorData* data = context->app_data;
if(current_mode(context) != MODE_HEX) return;
for(uint32_t i = 0; i < data->selected_count; i++) {
uint32_t region = data->selected_regions[i];
uint32_t hex = data->selected_hexes[i];
uint32_t triangle = data->selected_vertices[i];
uint32_t mask = context->hex.regions[region]->data.hexes[hex].flat_mask;
bool currently_flat = (mask >> triangle) & 1u;
set_hex_flat(!currently_flat, region, hex, triangle, context);
}
}
bool editor_pick(ClientContext* context, double cursor[2], uint32_t* rid, uint32_t* hid, uint32_t* vertex, uint32_t* triangle, bool edge_only) {
vec4 start, end;
float distance;
cursor_to_world_ray(&context->render, context->hex.inverse, cursor, start, end);
return ray_world_intersect(&distance, vertex, triangle, rid, hid, start, end, edge_only, &context->hex);
}
// Selection uses all highlight/point slots except the last, which is
// reserved for the hover preview (see refresh_hover_visuals).
void sync_hex_highlights(EditorData* data, ClientContext* context) {
EditorMode mode = current_mode(context);
// +1 for the reserved hover slot (see refresh_hover_visuals).
ensure_highlight_capacity(&context->hex, &context->render, data->selected_count + 1);
for(uint32_t i = 0; i < context->hex.cap_highlights - 1; i++) {
if(i < data->selected_count) {
GPUHighlight temp = {
// 0.25 alpha (was 1.0) so a color applied under the selection
// overlay is actually visible while still selected.
.color = {1.0f, 0.85f, 0.05f, 0.25f},
.region = data->selected_regions[i],
.hex = data->selected_hexes[i],
.offset = SELECTION_HIGHLIGHT_OFFSET,
// Hex mode selects one wedge at a time - highlight just that
// triangle so it's clear which one a color/flat edit will affect.
// Vertex mode keeps highlighting the whole hex as spatial context.
.triangle = (mode == MODE_HEX) ? data->selected_vertices[i] : 0xFFFFFFFF,
};
add_transfers(&temp, context->hex.highlights, sizeof(GPUHighlight)*i, sizeof(GPUHighlight), &context->render);
} else {
uint32_t disabled = 0xFFFFFFFF;
add_transfers(&disabled, context->hex.highlights, sizeof(GPUHighlight)*i + offsetof(GPUHighlight, hex), sizeof(uint32_t), &context->render);
}
}
}
void sync_vertex_points(EditorData* data, ClientContext* context) {
EditorMode mode = current_mode(context);
// Only grow for demand that will actually be drawn (Hex-mode selections
// never populate points - see below), so switching to Hex mode with a
// huge selection doesn't grow a buffer nothing will read.
if(mode == MODE_VERTEX) {
ensure_point_capacity(&context->hex, &context->render, data->selected_count + 1);
}
for(uint32_t i = 0; i < context->hex.cap_points - 1; i++) {
// Hex-mode selections are wedges, not vertices - selected_vertices[i]
// isn't a real vertex index there, so there's nothing for a point
// marker to draw (the wedge highlight above is the only visual).
if(mode == MODE_VERTEX && i < data->selected_count) {
GPUPoint temp = {
.color = {1.0f, 0.85f, 0.05f, 0.25f},
.region = data->selected_regions[i],
.hex = data->selected_hexes[i],
.vertex = data->selected_vertices[i],
.size = SELECTION_POINT_SIZE,
.offset = SELECTION_POINT_OFFSET,
};
add_transfers(&temp, context->hex.points, sizeof(GPUPoint)*i, sizeof(GPUPoint), &context->render);
} else {
uint32_t disabled = 0xFFFFFFFF;
add_transfers(&disabled, context->hex.points, sizeof(GPUPoint)*i + offsetof(GPUPoint, hex), sizeof(uint32_t), &context->render);
}
}
}
// Writes (or disables) the reserved hover slot. Color depends on whether
// the hovered element is already selected, so a click's effect (add vs.
// remove) is visible before the user commits to it.
void refresh_hover_visuals(EditorData* data, ClientContext* context) {
EditorMode mode = current_mode(context);
// No capacity check needed here: cap_highlights/cap_points start at
// MIN_HIGHLIGHTS/MIN_POINTS (create_hex_context) and only grow when
// selection does, via sync_hex_highlights/sync_vertex_points - so by the
// time this runs (whether after those, via refresh_selection_visuals, or
// on its own for a hover-only update) capacity already covers whatever
// the selection currently needs, and the hover slot just rides along at
// whatever the last index of that capacity is.
uint32_t highlight_slot = context->hex.cap_highlights - 1;
// would_remove and the hover highlight's shape (whole hex vs. one wedge)
// both key off the same mode-dependent hover_vertex meaning that
// find_selected_vertex/sync_hex_highlights use.
if((mode == MODE_HEX || mode == MODE_VERTEX) && data->hover_valid) {
bool would_remove = find_selected_vertex(data, data->hover_region, data->hover_hex, data->hover_vertex) != -1;
GPUHighlight temp;
if(would_remove) temp = (GPUHighlight){.color = HOVER_REMOVE_COLOR};
else temp = (GPUHighlight){.color = HOVER_ADD_COLOR};
temp.region = data->hover_region;
temp.hex = data->hover_hex;
temp.offset = HOVER_HIGHLIGHT_OFFSET;
temp.triangle = (mode == MODE_HEX) ? data->hover_vertex : 0xFFFFFFFF;
add_transfers(&temp, context->hex.highlights, sizeof(GPUHighlight)*highlight_slot, sizeof(GPUHighlight), &context->render);
} else {
uint32_t disabled = 0xFFFFFFFF;
add_transfers(&disabled, context->hex.highlights, sizeof(GPUHighlight)*highlight_slot + offsetof(GPUHighlight, hex), sizeof(uint32_t), &context->render);
}
uint32_t point_slot = context->hex.cap_points - 1;
if(mode == MODE_VERTEX && data->hover_valid) {
bool would_remove = find_selected_vertex(data, data->hover_region, data->hover_hex, data->hover_vertex) != -1;
GPUPoint temp;
if(would_remove) temp = (GPUPoint){.color = HOVER_REMOVE_COLOR};
else temp = (GPUPoint){.color = HOVER_ADD_COLOR};
temp.region = data->hover_region;
temp.hex = data->hover_hex;
temp.vertex = data->hover_vertex;
temp.size = HOVER_POINT_SIZE;
temp.offset = HOVER_POINT_OFFSET;
add_transfers(&temp, context->hex.points, sizeof(GPUPoint)*point_slot, sizeof(GPUPoint), &context->render);
} else {
uint32_t disabled = 0xFFFFFFFF;
add_transfers(&disabled, context->hex.points, sizeof(GPUPoint)*point_slot + offsetof(GPUPoint, hex), sizeof(uint32_t), &context->render);
}
}
void refresh_selection_visuals(EditorData* data, ClientContext* context) {
sync_hex_highlights(data, context);
sync_vertex_points(data, context);
refresh_hover_visuals(data, context);
}
// editor.mode is the single source of truth (a property on the event bus);
// nothing stores a separate copy. Reads are synchronous and cheap (a strcmp
// loop over MODE_MAX_ENUM short strings) so there's nothing worth caching.
EditorMode current_mode(ClientContext* context) {
const char* name = event_property(&context->events, "editor.mode")->value.string;
for(int i = 0; i < MODE_MAX_ENUM; i++) {
if(strcmp(ModeStrings[i], name) == 0) return (EditorMode)i;
}
return MODE_NONE;
}
// The only C-side way to change modes; script/editor_mode.lua changes modes
// by writing the same property directly via app.set instead. Either path
// queues engine.changed.editor.mode, which on_mode_changed below reacts to
// uniformly regardless of which path triggered it.
void editor_set_mode(ClientContext* context, EditorMode mode) {
event_property_set_string(&context->events, "editor.mode", ModeStrings[mode], EVENT_SOURCE_ENGINE);
}
// Selection/hover don't carry across modes; this is the only place that
// resets them, so it runs the same whether the mode change came from C or
// from a script's app.set.
static void on_mode_changed(void* userdata, const char* event, uint32_t source, lua_State* L, int args) {
(void)event;
(void)source;
(void)L;
(void)args;
ClientContext* context = userdata;
EditorData* data = context->app_data;
data->selected_count = 0;
data->hover_valid = false;
data->dragging = false;
refresh_selection_visuals(data, context);
}
void editor_button_callback(ClientContext* context, float x, float y, int button, int action, int mods) {
EditorData* data = context->app_data;
if(button != GLFW_MOUSE_BUTTON_LEFT) return;
// Checked ahead of the mode gate below so a release always clears the
// drag, even if the mode somehow changed while the button was still held.
if(action == GLFW_RELEASE) {
data->dragging = false;
return;
}
if(action != GLFW_PRESS) return;
EditorMode mode = current_mode(context);
if(mode != MODE_VERTEX && mode != MODE_HEX) return;
uint32_t rid, hid, v;
if(data->hover_valid) {
// editor_cursor_callback already raycast this exact spot for the hover
// preview; the cursor can't have moved between that and this click, so
// reuse it instead of raycasting again.
rid = data->hover_region;
hid = data->hover_hex;
v = data->hover_vertex;
} else {
double cursor[2] = {x, y};
uint32_t vertex, triangle;
// Vertex mode requests edge-only picking so a click always resolves to a
// real, editable vertex instead of frequently landing on the hex center
// (vertex 0) and giving no feedback.
if(!editor_pick(context, cursor, &rid, &hid, &vertex, &triangle, mode == MODE_VERTEX)) return;
v = (mode == MODE_VERTEX) ? vertex : triangle;
}
// find_selected_vertex is a plain 3-tuple match despite its name - used
// here for Hex mode too now that the third field is a wedge index, so two
// different wedges of the same hex are distinct selections.
int32_t idx = find_selected_vertex(data, rid, hid, v);
// Starts a drag-select session: editor_cursor_callback extends this same
// add/remove toggle to whatever becomes newly hovered while the button
// stays down (see the "dragging" field's comment in editor.h).
data->dragging = true;
data->drag_remove = (mods & GLFW_MOD_CONTROL) != 0;
// Left click adds to the selection; Shift is reserved for camera movement
// (GLFW_KEY_LEFT_SHIFT) so it carries no selection meaning here. Ctrl
// removes. Mode changes remain the only way to reset the selection.
if(mods & GLFW_MOD_CONTROL) {
if(idx != -1) remove_selected_at(data, (uint32_t)idx);
} else if(idx == -1) {
add_selected(data, rid, hid, v);
}
refresh_selection_visuals(data, context);
}
void editor_cursor_callback(ClientContext* context, float x, float y) {
EditorData* data = context->app_data;
EditorMode mode = current_mode(context);
if(mode != MODE_VERTEX && mode != MODE_HEX) {
if(data->hover_valid) {
data->hover_valid = false;
refresh_hover_visuals(data, context);
}
return;
}
double cursor[2] = {x, y};
uint32_t rid, hid, vertex, triangle;
bool hit = editor_pick(context, cursor, &rid, &hid, &vertex, &triangle, mode == MODE_VERTEX);
uint32_t v = (mode == MODE_VERTEX) ? vertex : triangle;
// Skip the GPU write unless the hovered element actually changed; cursor
// motion fires far more often than the hover target changes. v is now a
// meaningful varying value in both modes (a real vertex in Vertex mode, a
// wedge in Hex mode), so it's always part of the comparison.
bool changed = hit != data->hover_valid
|| (hit && (data->hover_region != rid || data->hover_hex != hid
|| data->hover_vertex != v));
if(!changed) return;
data->hover_valid = hit;
if(hit) {
data->hover_region = rid;
data->hover_hex = hid;
data->hover_vertex = v;
}
// Drag-select: extend the initiating click's add/remove toggle to
// whatever just became hovered, same idx check as editor_button_callback
// uses for a plain click - so gliding back over an already-selected item
// during a plain (non-Ctrl) drag is a no-op, not a re-toggle.
if(data->dragging && hit) {
int32_t idx = find_selected_vertex(data, rid, hid, v);
if(data->drag_remove) {
if(idx != -1) remove_selected_at(data, (uint32_t)idx);
} else if(idx == -1) {
add_selected(data, rid, hid, v);
}
refresh_selection_visuals(data, context);
} else {
refresh_hover_visuals(data, context);
}
}
void editor_startup(ClientContext* context) {
EditorData* data = context->app_data;
editor_lua_register(context->ui.lua, context);
// Application state surface visible to scripts; registered before any
// container loads so app.get sees the initial values
event_property_register(&context->events, "editor.mode", PROPERTY_STRING);
event_property_register(&context->events, "editor.color", PROPERTY_STRING);
event_property_set_string(&context->events, "editor.mode", ModeStrings[MODE_NONE], EVENT_SOURCE_ENGINE);
event_property_set_string(&context->events, "editor.color", "#000000FF", EVENT_SOURCE_ENGINE);
// Registered before any script loads so it's guaranteed to see mode
// changes editor_mode.lua triggers, ahead of editor_ui.lua's own reaction
event_subscribe(&context->events, "engine.changed.editor.mode", on_mode_changed, context);
// Controller script: owns the mode label and the color picker overlay,
// both driven entirely by the editor.mode property from here on
ui_lua_run_script(context->ui.lua, &context->ui, &context->render, "script/editor_ui.lua");
// Input->state-machine trigger: writes editor.mode on V/N/H/R/Escape
ui_lua_run_script(context->ui.lua, &context->ui, &context->render, "script/editor_mode.lua");
// Height nudge (=/-) and flat toggle (F) for the current selection
ui_lua_run_script(context->ui.lua, &context->ui, &context->render, "script/editor_paint.lua");
// Main 3D view: a full-window container hosting the interactive camera,
// same as every other overlay - see container_set_camera (ui.h). Screen-
// region targeting lives on the container, not the camera, so this is
// the only place that needs to know the camera renders full-window.
ContainerInput main_view = {
.id = ui_alloc_container_id(&context->ui),
.anchor = ANCHOR_TOP_LEFT,
.offset = {0, 0},
.size = {
context->render.swapchain_extent.width / context->render.window_scale[0],
context->render.swapchain_extent.height / context->render.window_scale[1],
},
};
load_container(&main_view, &context->render, &context->ui);
data->main_container = context_container(main_view.id, &context->ui);
container_set_camera(data->main_container, &context->camera);
// The editor sets the camera's initial values and computes its first
// view/projection here; editor_frame_callback only recomputes them when
// spin/velocity/zoom (or a resize) happen, so without this the initial
// view stays whatever ClientContext's zero-init left it as until the
// camera is first moved.
context->camera.rotation[0] = 3*M_PI/2;
context->camera.rotation[1] = M_PI/4;
context->camera.distance = 25;
camera_update_view(&context->camera);
camera_update_proj(&context->camera, (float)context->render.swapchain_extent.width/(float)context->render.swapchain_extent.height);
camera_sync_gpu(&context->camera, &context->render);
update_hex_picking_inverse(&context->camera, &context->hex);
// Top-down minimap: a second, script-owned camera - proves camera
// creation/attachment isn't C-only. See script/editor_topdown.lua.
ui_lua_run_script(context->ui.lua, &context->ui, &context->render, "script/editor_topdown.lua");
// TODO: Remove when region mode is implemented
add_hex_region(context);
}
EditorData* create_editor_data(void) {
EditorData* data = malloc(sizeof(EditorData));
memset(data, 0, sizeof(EditorData));
data->selected_count = 0;
resize_selected(data, 1);
data->spin_speed = 1.0;
data->zoom_speed = 0.5;
data->move_speed = 0.1;
// Mode-switch keys (Escape/V/N/H/R) moved to script/editor_mode.lua,
// triggered by the engine.key event instead of this table
data->mode_key_counts[MODE_NONE] = 10;
for(int i = 0; i < MODE_MAX_ENUM; i++) {
data->mode_keys[i] = malloc(sizeof(ModeKey)*data->mode_key_counts[i]);
}
// Camera Movement (axis: 0 = strafe x, 1 = up/down, 2 = forward/back)
data->mode_keys[MODE_NONE][0] = (ModeKey){GLFW_KEY_SPACE, move_cam_key, 1, 1};
data->mode_keys[MODE_NONE][1] = (ModeKey){GLFW_KEY_LEFT_SHIFT, move_cam_key, 1, -1};
data->mode_keys[MODE_NONE][2] = (ModeKey){GLFW_KEY_LEFT, move_cam_key, 0, -1};
data->mode_keys[MODE_NONE][3] = (ModeKey){GLFW_KEY_RIGHT, move_cam_key, 0, 1};
data->mode_keys[MODE_NONE][4] = (ModeKey){GLFW_KEY_UP, move_cam_key, 2, 1};
data->mode_keys[MODE_NONE][5] = (ModeKey){GLFW_KEY_DOWN, move_cam_key, 2, -1};
// Camera Spin (axis: 0 = yaw, 1 = pitch)
data->mode_keys[MODE_NONE][6] = (ModeKey){GLFW_KEY_A, spin_cam_key, 0, -1};
data->mode_keys[MODE_NONE][7] = (ModeKey){GLFW_KEY_D, spin_cam_key, 0, 1};
data->mode_keys[MODE_NONE][8] = (ModeKey){GLFW_KEY_W, spin_cam_key, 1, 1};
data->mode_keys[MODE_NONE][9] = (ModeKey){GLFW_KEY_S, spin_cam_key, 1, -1};
return data;
}
void destroy_editor_data(EditorData* data) {
for(int i = 0; i < MODE_MAX_ENUM; i++) {
free(data->mode_keys[i]);
}
free(data->selected_regions);
free(data->selected_hexes);
free(data->selected_vertices);
free(data);
}
Reference in New Issue View Git Blame Copy Permalink