add trees into the game

src/main.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <stdio.h>
 #include <stdint.h>
 #include <bit>
@@ -9,6 +10,7 @@
 #include <tracy/Tracy.hpp>
 #include <tracy/TracyC.h>
 #include <webgpu/webgpu.h>
+#include "smol-atlas.h"
 
 #include <glm/glm.hpp>
 #include <glm/gtc/type_ptr.hpp>
@@ -31,6 +33,7 @@ using namespace glm;
 
 #define TILE_SIZE        (32)
 #define TILE_ATLAS_SIZE  (512)
+#define TREE_ATLAS_SIZE  (256)
 
 static SDL_Window *window;
 static R_Texture  framebuffer;
@@ -39,13 +42,17 @@ static R_Texture player_texture;
 static R_Texture character_shadow_texture;
 static R_Texture tile_textures_atlas;
 static R_Texture tile_textures_atlas_imgui;
+static R_Texture tree_textures_atlas;
+static R_Texture tree_textures_atlas_imgui;
 
 static R_Buffer view_projection_matrix_buffer;
 static R_Buffer per_frame_buffer;
 static R_Buffer tint_color_buffer;
 
 static R_Buffer player_instance_buffer;
+static R_Buffer trees_instance_buffer;
 static R_Buffer tile_uvs_buffer;
+static R_Buffer tree_uvs_buffer;
 
 static i32vec2 window_size = { 1280, 720 };
 
@@ -87,6 +94,7 @@ static float editor_camera_distance = 30.0f;
 
 static bool show_demo_window;
 static bool show_tile_picker;
+static bool show_tree_editor;
 static bool show_settings;
 
 static float character_speed = 4.0f;
@@ -175,15 +183,22 @@ struct Instance {
 
 static Instance player_instance = {{ 0.0f, 0.0f }};
 
-struct Map {
-    Uint32 version;
+struct Tree {
+    u32vec2 pos;
+    Uint32 kind;
+};
 
+struct Map {
     i32vec2 size;
     Uint16 *tiles;
 
+    Uint32 num_trees;
+    Tree  *trees;
+
     char name[64];
 
     R_Texture texture;
+    R_Buffer  trees_buffer;
 };
 
 static Map current_map;
@@ -395,6 +410,19 @@ static TileInfo tile_infos[] = {
 
 static vec4 tile_uvs[SDL_arraysize(tile_infos)];
 
+struct TreeInfo {
+    Uint16      serialization_id;
+    const char *asset_path;
+};
+
+static TreeInfo tree_infos[] = {
+    { 0, "decorations/tree_standard_tile.png" },
+};
+
+static vec4 tree_uvs[SDL_arraysize(tree_infos)];
+
+static Sint32 selected_tree = -1;
+
 static Sint32 selected_tile_kind = -1;
 static Sint32 selected_tile      = -1;
 
@@ -427,11 +455,12 @@ static R_Texture create_texture(const char *path) {
     return result;
 }
 
-#define MAP_FILE_VERSION (2u)
+#define MAP_FILE_VERSION (3u)
 
 static bool save_map(Map map) {
     char path[256] = ASSETS_PATH "maps/";
     SDL_strlcat(path, map.name, SDL_arraysize(path));
+    SDL_strlcat(path, ".sv", SDL_arraysize(path));
 
     SDL_IOStream *file = SDL_IOFromFile(path, "wb");
     if (!file) {
@@ -464,6 +493,30 @@ static bool save_map(Map map) {
         }
     }
 
+    if (!SDL_WriteU32LE(file, map.num_trees)) {
+        log_error("Failed to write num_trees to map file.");
+        return false;
+    }
+
+    for (int i = 0; i < map.num_trees; i++) {
+        Uint16 id = tree_infos[map.trees[i].kind].serialization_id;
+
+        if (!SDL_WriteU16LE(file, id)) {
+            log_error("Failed to write tree kind to map file.");
+            return false;
+        }
+
+        if (!SDL_WriteU32LE(file, map.trees[i].pos.x)) {
+            log_error("Failed to write tree pos.x to map file.");
+            return false;
+        }
+
+        if (!SDL_WriteU32LE(file, map.trees[i].pos.y)) {
+            log_error("Failed to write tree pos.y to map file.");
+            return false;
+        }
+    }
+
     if(!SDL_FlushIO(file)) {
         log_error("Failed to flush data to map file.");
         return false;   
@@ -476,6 +529,7 @@ static bool save_map(Map map) {
 static bool load_map(const char *name, Map *result) {
     char path[256] = ASSETS_PATH "maps/";
     SDL_strlcat(path, name, SDL_arraysize(path));
+    SDL_strlcat(path, ".sv", SDL_arraysize(path));
 
     SDL_IOStream *file = SDL_IOFromFile(path, "rb");
     if (!file) {
@@ -485,13 +539,19 @@ static bool load_map(const char *name, Map *result) {
     defer(SDL_CloseIO(file));
     SDL_memcpy(result->name, name, SDL_min(strlen(name), SDL_arraysize(result->name) - 1));
 
-    if (!SDL_ReadU32LE(file, &result->version)) {
+    Uint32 version = 0;
+    if (!SDL_ReadU32LE(file, &version)) {
         log_error("Failed read version from map file.");
         return false;
     }
 
-    if (result->version > MAP_FILE_VERSION) {
-        log_error("Map file version (%u) is higher than the highest supported.", result->version);
+    if (!version) {
+        log_error("Map file version for map '%s' was 0 which is not valid.", name);
+        return false;
+    }
+
+    if (version > 3) {
+        log_error("Map file version (%u) is higher than the highest supported.", version);
         return false;
     }
 
@@ -505,10 +565,10 @@ static bool load_map(const char *name, Map *result) {
         return false;
     }
 
-    result->tiles = (Uint16*)malloc(result->size.x * result->size.y * sizeof(Uint16));
+    result->tiles = (Uint16 *)SDL_malloc(result->size.x * result->size.y * sizeof(Uint16));
 
     for (int i = 0; i < result->size.x * result->size.y; i++) {
-        if (result->version == 2) {
+        if (version >= 2) {
             Uint16 serialization_id = 0;
             if (!SDL_ReadU16LE(file, &serialization_id)) {
                 free(result->tiles);
@@ -532,11 +592,58 @@ static bool load_map(const char *name, Map *result) {
         }
     }
 
+    if (version >= 3) {
+        if (!SDL_ReadU32LE(file, &result->num_trees)) {
+            log_error("Failed to read num_trees from map file.");
+            free(result->tiles);
+            return false;
+        }
+
+        result->trees = (Tree *)SDL_malloc(result->num_trees * sizeof(Tree));
+
+        for (int i = 0; i < result->num_trees; i++) {
+            Uint16 serialization_id = 0;
+            if (!SDL_ReadU16LE(file, &serialization_id)) {
+                free(result->tiles);
+                free(result->trees);
+                return false;
+            }
+
+            Uint16 info_index = 0;
+            for (int i = 0; i < SDL_arraysize(tree_infos); i++) {
+                if (tree_infos[i].serialization_id == serialization_id) {
+                    info_index = i;
+                    break;
+                }
+            }
+
+            result->trees[i].kind = info_index;
+
+            if (!SDL_ReadU32LE(file, &result->trees[i].pos.x)) {
+                free(result->tiles);
+                free(result->trees);
+                log_error("Failed to read tree pos.x from map file.");
+                return false;
+            }
+
+            if (!SDL_ReadU32LE(file, &result->trees[i].pos.y)) {
+                free(result->tiles);
+                free(result->trees);
+                log_error("Failed to read tree pos.y from map file.");
+                return false;
+            }
+        }
+    }
+
     char buffer_name[256] = "Map ";
     SDL_strlcat(buffer_name, result->name, SDL_arraysize(buffer_name));
 
     result->texture = renderer_texture_create(R_TEXTURE_FORMAT_R16_UINT, R_TEXTURE_USAGE_STORAGE, false, result->size.x, result->size.y, result->tiles, "map_texture");
 
+    if (result->num_trees) {
+        result->trees_buffer = renderer_buffer_create(R_BUFFER_USAGE_VERTEX, result->num_trees * sizeof(*result->trees), result->trees, "trees_buffer");
+    }
+
     SDL_Log("Loaded map file.");
     return true;
 }
@@ -639,6 +746,20 @@ static bool SelectableTile(const char *label, bool selected, Uint32 tile_index,
     return pressed;
 }
 
+static bool SelectableImage(const char *label, R_Texture texture, ImVec2 image_size, vec2 uv_min, vec2 uv_max, bool selected) {
+    const ImGuiContext *context = ImGui::GetCurrentContext();
+    const ImVec2 padding = context->Style.FramePadding;
+
+    bool pressed = ImGui::Selectable(label, selected, 0, ImVec2(image_size.x, image_size.y) + padding * 2.0f);
+
+    ImVec2 min = ImGui::GetItemRectMin();
+    ImVec2 max = ImGui::GetItemRectMax();
+
+    context->CurrentWindow->DrawList->AddImageQuad((ImTextureID)ImGui_ImplRenderer_GetTextureID(texture), min + padding, ImVec2(max.x - padding.x, min.y + padding.y), max - padding, ImVec2(min.x + padding.x, max.y - padding.y), ImVec2(uv_min.x, uv_min.y), ImVec2(uv_max.x, uv_min.y), ImVec2(uv_max.x, uv_max.y), ImVec2(uv_min.x, uv_max.y));
+
+    return pressed;
+}
+
 static ImVec4 linear_to_sRGB(ImVec4 linear) {
     float red   = linear.x <= 0.0031308f ? 12.92f * linear.x : 1.055f * powf(linear.x, 1.0f / 2.4f) - 0.055;
     float green = linear.y <= 0.0031308f ? 12.92f * linear.y : 1.055f * powf(linear.y, 1.0f / 2.4f) - 0.055;
@@ -776,6 +897,68 @@ static bool recreate_tile_textures() {
     return true;
 }
 
+static bool recreate_tree_textures() {
+    smol_atlas_t *tree_atlas = sma_atlas_create(TREE_ATLAS_SIZE, TREE_ATLAS_SIZE);
+    smol_atlas_item_t **tree_atlas_items = (smol_atlas_item_t **)SDL_calloc(SDL_arraysize(tree_infos), sizeof(smol_atlas_item_t *));
+
+    defer(sma_atlas_destroy(tree_atlas));
+    defer(SDL_free(tree_atlas_items));
+
+    for (Uint32 i = 0; i < SDL_arraysize(tree_infos); i++) {
+        char path[256] = ASSETS_PATH;
+        SDL_strlcat(path, tree_infos[i].asset_path, SDL_arraysize(path));
+
+        int width = 0, height = 0;
+        if (!stbi_info(path, &width, &height, NULL))
+            return false;
+
+        tree_atlas_items[i] = sma_item_add(tree_atlas, width, height);
+        if (!tree_atlas_items[i])
+            return false;
+    }
+
+    tree_textures_atlas = renderer_texture_create(R_TEXTURE_FORMAT_RGBA8_UNORM_SRGB, R_TEXTURE_USAGE_SAMPLED, false, TREE_ATLAS_SIZE, TREE_ATLAS_SIZE, NULL, "tree_atlas_texture");
+    if (!tree_textures_atlas) {
+        log_error("Failed to create texture.");
+        return false;
+    }
+
+    tree_textures_atlas_imgui = renderer_texture_create(R_TEXTURE_FORMAT_RGBA8_UNORM, R_TEXTURE_USAGE_SAMPLED, false, TREE_ATLAS_SIZE, TREE_ATLAS_SIZE, NULL, "tree_atlas_texture imgui");
+    if (!tree_textures_atlas_imgui) {
+        log_error("Failed to create texture.");
+        return false;
+    }
+
+    for (Uint32 i = 0; i < SDL_arraysize(tree_infos); i++) {
+        char path[256] = ASSETS_PATH;
+        SDL_strlcat(path, tree_infos[i].asset_path, SDL_arraysize(path));
+
+        int width = 0, height = 0;
+        stbi_uc *data = stbi_load(path, &width, &height, NULL, 4);
+        if (!data) {
+            log_error("Failed to load texture (\"%s\"). Exiting.", path);
+            renderer_texture_destroy(tree_textures_atlas);
+            tree_textures_atlas = NULL;
+            renderer_texture_destroy(tree_textures_atlas_imgui);
+            tree_textures_atlas_imgui = NULL;
+            return false;
+        }
+
+        tree_uvs[i].x = sma_item_x(tree_atlas_items[i]);
+        tree_uvs[i].y = sma_item_y(tree_atlas_items[i]);
+        tree_uvs[i].z = sma_item_x(tree_atlas_items[i]) + sma_item_width (tree_atlas_items[i]);
+        tree_uvs[i].w = sma_item_y(tree_atlas_items[i]) + sma_item_height(tree_atlas_items[i]);
+
+        renderer_texture_update(tree_textures_atlas,       sma_item_x(tree_atlas_items[i]), sma_item_y(tree_atlas_items[i]), sma_item_width(tree_atlas_items[i]), sma_item_height(tree_atlas_items[i]), data, sma_item_width(tree_atlas_items[i]) * 4);
+        renderer_texture_update(tree_textures_atlas_imgui, sma_item_x(tree_atlas_items[i]), sma_item_y(tree_atlas_items[i]), sma_item_width(tree_atlas_items[i]), sma_item_height(tree_atlas_items[i]), data, sma_item_width(tree_atlas_items[i]) * 4);
+        stbi_image_free(data);
+    }
+
+    tree_uvs_buffer = renderer_buffer_create(R_BUFFER_USAGE_STORAGE, sizeof(tree_uvs), tree_uvs, "tree_uvs_buffer");
+
+    return true;
+}
+
 static int real_mod(int a, int b) {
     int result = a % b;
     return result >= 0 ? result : result + b;
@@ -854,6 +1037,13 @@ static i32vec2 grid_tile_pos_from_floor_intersection(vec2 floor_intersection) {
     };
 }
 
+static i32vec2 grid_entity_pos_from_floor_intersection(vec2 floor_intersection) {
+    return {
+        (Sint32)SDL_floorf(floor_intersection.x + 0.5f),
+        (Sint32)SDL_floorf(floor_intersection.y + 0.5f),
+    };
+}
+
 static bool init_resources() {
     view_projection_matrix_buffer = renderer_buffer_create(R_BUFFER_USAGE_UNIFORM, sizeof(mat4x4), NULL, "view_projection_matrix_buffer");
     if (!view_projection_matrix_buffer) {
@@ -896,6 +1086,11 @@ static bool init_resources() {
         return false;
     }
 
+    if (!recreate_tree_textures()) {
+        log_error("Failed to create tree textures.");
+        return false;
+    }
+
     return true;
 }
 
@@ -953,7 +1148,8 @@ static void process_event_editor(SDL_Event event) {
                 return;
 
             vec2 floor_intersection = get_floor_intersection_of_mouse(vec2(event.button.x, event.button.y));
-            i32vec2 tile_pos = grid_tile_pos_from_floor_intersection(floor_intersection);
+            i32vec2 tile_pos   = grid_tile_pos_from_floor_intersection(floor_intersection);
+            i32vec2 entity_pos = grid_entity_pos_from_floor_intersection(floor_intersection);
 
             drag_start_pos = floor_intersection;
 
@@ -962,6 +1158,48 @@ static void process_event_editor(SDL_Event event) {
             }
 
             if (event.button.button == SDL_BUTTON_LEFT) {
+                if (selected_tree != -1 && 0 <= tile_pos.x && tile_pos.x < current_map.size.x -1 && 0 <= tile_pos.y && tile_pos.y < current_map.size.y - 1) {
+                    Sint32 found_tree = -1;
+                    for (Sint32 i = 0; i < current_map.num_trees; i++) {
+                        if ((current_map.trees[i].pos.x == entity_pos.x) && (current_map.trees[i].pos.y == entity_pos.y)) {
+                            found_tree = i;
+                            break;
+                        }
+                    }
+                    
+                    if (found_tree != -1) {
+                        Tree tmp = current_map.trees[found_tree];
+                        SDL_memmove(&current_map.trees[found_tree], &current_map.trees[found_tree + 1], (current_map.num_trees - (found_tree + 1)) * sizeof(*current_map.trees));
+                        current_map.trees[current_map.num_trees - 1] = tmp;
+                    } else {
+                        current_map.trees = (Tree *)SDL_realloc(current_map.trees, (current_map.num_trees + 1) * sizeof(*current_map.trees));
+                        current_map.trees[current_map.num_trees] = {
+                            .pos = entity_pos,
+                            .kind = (Uint32)selected_tree,
+                        };
+
+                        current_map.num_trees++;
+                    }
+
+                    std::stable_sort(&current_map.trees[0], &current_map.trees[current_map.num_trees], [](const Tree &a, const Tree &b){ return a.pos.y > b.pos.y; });
+
+                    if (current_map.trees_buffer) renderer_buffer_destroy(current_map.trees_buffer);
+                    current_map.trees_buffer = renderer_buffer_create(R_BUFFER_USAGE_VERTEX, current_map.num_trees * sizeof(*current_map.trees), current_map.trees, "trees_buffer");
+                }
+
+                if (show_tree_editor && selected_tree == -1) {
+                    for (Sint32 i = 0; i < current_map.num_trees; i++) {
+                        if ((current_map.trees[i].pos.x == entity_pos.x) && (current_map.trees[i].pos.y == entity_pos.y)) {
+                            SDL_memmove(&current_map.trees[i], &current_map.trees[i + 1], (current_map.num_trees - (i + 1)) * sizeof(*current_map.trees));
+                            current_map.num_trees--;
+                            break;
+                        }
+                    }
+
+                    if (current_map.trees_buffer) renderer_buffer_destroy(current_map.trees_buffer);
+                    if (current_map.num_trees)    current_map.trees_buffer = renderer_buffer_create(R_BUFFER_USAGE_VERTEX, current_map.num_trees * sizeof(*current_map.trees), current_map.trees, "trees_buffer");
+                }
+
                 if (selected_tile_kind != -1) {
                     change_map_tile(tile_pos.x, tile_pos.y, (TileKind)selected_tile_kind);
 
@@ -1075,6 +1313,7 @@ static void update_state_editor() {
         if (ImGui::BeginMenu("File")) {
             if (ImGui::MenuItem("Reload")) {
                 recreate_tile_textures();
+                recreate_tree_textures();
             }
 
             if (ImGui::MenuItem("Save")) {
@@ -1095,6 +1334,7 @@ static void update_state_editor() {
 
         if (ImGui::BeginMenu("Edit")) {
             ImGui::MenuItem("Tile Picker", NULL, &show_tile_picker);
+            ImGui::MenuItem("Trees",       NULL, &show_tree_editor);
             ImGui::EndMenu();
         }
 
@@ -1109,6 +1349,7 @@ static void update_state_editor() {
 
         ImGuiID left_dock = ImGui::DockBuilderSplitNode(main_viewport_dock, ImGuiDir_Left, 0.2f, NULL, NULL);
         ImGui::DockBuilderDockWindow("Tile Picker", left_dock);
+        ImGui::DockBuilderDockWindow("Trees", left_dock);
         ImGui::DockBuilderFinish(main_viewport_dock);
     }
     ImGui::DockSpaceOverViewport(main_viewport_dock, ImGui::GetMainViewport(), ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_PassthruCentralNode | ImGuiDockNodeFlags_NoDockingOverCentralNode);
@@ -1227,6 +1468,29 @@ static void update_state_editor() {
         selected_tile_kind = -1;
     }
 
+    if (show_tree_editor) {
+        if (ImGui::Begin("Trees", &show_tree_editor, ImGuiWindowFlags_NoFocusOnAppearing)) {
+            ImGuiStyle &style = ImGui::GetStyle();
+            if (SelectableImage("##tree", tree_textures_atlas_imgui, ImVec2(64, 64), vec2(0, 0), vec2(0, 0), selected_tree == -1))
+                selected_tree = -1;
+
+            for (int i = 0; i < SDL_arraysize(tree_infos); i++) {
+                ImGui::PushID(i);
+
+                if (i != 0)
+                    SameLineOrWrap(ImVec2(64, 1));
+
+                if (SelectableImage("##tree", tree_textures_atlas_imgui, ImVec2(tree_uvs[i].z, tree_uvs[i].w), tree_uvs[i].xy() / (float)TREE_ATLAS_SIZE, tree_uvs[i].zw() / (float)TREE_ATLAS_SIZE, selected_tree == i))
+                    selected_tree = i;
+
+                ImGui::PopID();
+            }
+        }
+        ImGui::End();
+    } else {
+        selected_tree = -1;
+    }
+
     ImGui::SetNextWindowPos({ viewport->WorkPos.x + viewport->WorkSize.x - 10.0f, viewport->WorkPos.y + 10.0f }, ImGuiCond_Always, { 1.0f, 0.0f });
     if (ImGui::Begin("Overlay", NULL, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav)) {
         ImGui::Checkbox("Grid", &show_grid);
@@ -1331,6 +1595,24 @@ static void render_editor() {
         });
     }
 
+    if (current_map.num_trees) {
+        ZoneScopedN("Draw Trees");
+        renderer_frame_set_shader(R_SHADER_TREE);
+        renderer_frame_draw(NULL, NULL, current_map.trees_buffer, 6, current_map.num_trees, &(R_Draw_Resources){
+            .vertex_uniform_buffers  = (R_Buffer[]){ view_projection_matrix_buffer, per_frame_buffer },
+
+            .num_vertex_uniform_buffers  = 2,
+
+            .fragment_sampled_textures = (R_Texture[]){ tree_textures_atlas },
+            .fragment_storage_buffers  = (R_Buffer[]){ tree_uvs_buffer },
+            .fragment_uniform_buffers  = (R_Buffer[]){ tint_color_buffer },
+
+            .num_fragment_sampled_textures = 1,
+            .num_fragment_storage_buffers  = 1,
+            .num_fragment_uniform_buffers  = 1,
+        });
+    }
+
     if (show_grid) {
         ZoneScopedN("Draw Grid");
 
@@ -1530,6 +1812,24 @@ static void render_game() {
         });
     }
 
+    if (current_map.num_trees) {
+        ZoneScopedN("Draw Trees");
+        renderer_frame_set_shader(R_SHADER_TREE);
+        renderer_frame_draw(NULL, NULL, current_map.trees_buffer, 6, current_map.num_trees, &(R_Draw_Resources){
+            .vertex_uniform_buffers  = (R_Buffer[]){ view_projection_matrix_buffer, per_frame_buffer },
+
+            .num_vertex_uniform_buffers  = 2,
+
+            .fragment_sampled_textures = (R_Texture[]){ tree_textures_atlas },
+            .fragment_storage_buffers  = (R_Buffer[]){ tree_uvs_buffer },
+            .fragment_uniform_buffers  = (R_Buffer[]){ tint_color_buffer },
+
+            .num_fragment_sampled_textures = 1,
+            .num_fragment_storage_buffers  = 1,
+            .num_fragment_uniform_buffers  = 1,
+        });
+    }
+
     {
         ZoneScopedN("Draw Player");
         renderer_frame_set_shader(R_SHADER_CHARACTER_SHADOW);
@@ -1748,7 +2048,7 @@ int main(int argc, char **argv) {
         return 1;
     }
 
-    if (!load_map("map.sv", &current_map)) {
+    if (!load_map("map", &current_map)) {
         log_error("Failed to load initial map. Exiting.");
         return 1;
     }