Ammerhai/Mikemon
2
0
Fork 0
Code Issues 7 Pull Requests Packages Projects 2 Releases 1 Wiki Activity

rename Tree to placeable and dynamically load size
buildbot/windows Build done.
Details
buildbot/linux Build done.
Details

Browse Source 
add stone variants as placeables
This commit is contained in:
Sven Balzer
2026-08-06 19:45:47 +02:00
parent ff82f59fdf
commit ecd6571785
9 changed files with 204 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main.cpp
+140 -123
View File
@@ -33,9 +33,9 @@ using namespace glm;
#define NEAR_PLANE (0.01f)
#define TILE_SIZE (32)
#define TILE_ATLAS_SIZE (512)
#define TREE_ATLAS_SIZE (256)
#define TILE_SIZE (32)
#define TILE_ATLAS_SIZE (512)
#define PLACEABLE_ATLAS_SIZE (256)
static SDL_Window *window;
static R_Texture framebuffer;
@@ -44,17 +44,18 @@ 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_Texture placeable_textures_atlas;
static R_Texture placeable_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 placeable_instance_buffer;
static R_Buffer tile_uvs_buffer;
static R_Buffer tree_uvs_buffer;
static R_Buffer placeable_uvs_buffer;
static R_Buffer placeable_sizes_and_offsets_buffer;
static i32vec2 window_size = { 1280, 720 };
@@ -96,7 +97,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_placeable_editor;
static bool show_world_editor;
static bool show_settings;
@@ -186,22 +187,22 @@ struct Instance {
static Instance player_instance = {{ 0.0f, 0.0f }};
struct Tree {
struct Placeable {
u32vec2 pos;
Uint32 kind;
Uint32 kind;
};
struct Map {
i32vec2 size;
Uint16 *tiles;
Uint32 num_trees;
Tree *trees;
Uint32 num_placeables;
Placeable *placeables;
char name[64];
R_Texture texture;
R_Buffer trees_buffer;
R_Buffer placeables_buffer;
};
static Uint32 num_loaded_maps;
@@ -415,18 +416,22 @@ static TileInfo tile_infos[] = {
static vec4 tile_uvs[SDL_arraysize(tile_infos)];
struct TreeInfo {
struct PlaceableInfo {
Uint16 serialization_id;
const char *asset_path;
vec2 visual_offset;
};
static TreeInfo tree_infos[] = {
{ 0, "decorations/tree_standard_tile_angle.png" },
static PlaceableInfo placeable_infos[] = {
{ 0, "decorations/tree_standard_tile_angle.png", vec2(0, 0.25) },
{ 1, "decorations/Stone.png", vec2(0, 0) },
{ 2, "decorations/stone_grass.png", vec2(0, 0) },
};
static vec4 tree_uvs[SDL_arraysize(tree_infos)];
static vec4 placeable_uvs [SDL_arraysize(placeable_infos)];
static vec4 placeable_sizes_and_offsets[SDL_arraysize(placeable_infos)];
static Sint32 selected_tree = -1;
static Sint32 selected_placeable = -1;
static Sint32 selected_tile_kind = -1;
static Sint32 selected_tile = -1;
@@ -524,26 +529,26 @@ static bool save_map(Map *map) {
}
}
if (!SDL_WriteU32LE(file, map->num_trees)) {
log_error("Failed to write num_trees to map file.");
if (!SDL_WriteU32LE(file, map->num_placeables)) {
log_error("Failed to write num_placeable to map file.");
return false;
}
for (int i = 0; i < map->num_trees; i++) {
Uint16 id = tree_infos[map->trees[i].kind].serialization_id;
for (int i = 0; i < map->num_placeables; i++) {
Uint16 id = placeable_infos[map->placeables[i].kind].serialization_id;
if (!SDL_WriteU16LE(file, id)) {
log_error("Failed to write tree kind to map file.");
log_error("Failed to write placeables 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.");
if (!SDL_WriteU32LE(file, map->placeables[i].pos.x)) {
log_error("Failed to write placeables 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.");
if (!SDL_WriteU32LE(file, map->placeables[i].pos.y)) {
log_error("Failed to write placeables pos.y to map file.");
return false;
}
}
@@ -624,43 +629,43 @@ 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.");
if (!SDL_ReadU32LE(file, &result->num_placeables)) {
log_error("Failed to read num_placeables from map file.");
free(result->tiles);
return false;
}
result->trees = (Tree *)SDL_malloc(result->num_trees * sizeof(Tree));
result->placeables = (Placeable *)SDL_malloc(result->num_placeables * sizeof(Placeable));
for (int i = 0; i < result->num_trees; i++) {
for (int i = 0; i < result->num_placeables; i++) {
Uint16 serialization_id = 0;
if (!SDL_ReadU16LE(file, &serialization_id)) {
free(result->tiles);
free(result->trees);
free(result->placeables);
return false;
}
Uint16 info_index = 0;
for (int i = 0; i < SDL_arraysize(tree_infos); i++) {
if (tree_infos[i].serialization_id == serialization_id) {
for (int i = 0; i < SDL_arraysize(placeable_infos); i++) {
if (placeable_infos[i].serialization_id == serialization_id) {
info_index = i;
break;
}
}
result->trees[i].kind = info_index;
result->placeables[i].kind = info_index;
if (!SDL_ReadU32LE(file, &result->trees[i].pos.x)) {
if (!SDL_ReadU32LE(file, &result->placeables[i].pos.x)) {
free(result->tiles);
free(result->trees);
log_error("Failed to read tree pos.x from map file.");
free(result->placeables);
log_error("Failed to read placeable pos.x from map file.");
return false;
}
if (!SDL_ReadU32LE(file, &result->trees[i].pos.y)) {
if (!SDL_ReadU32LE(file, &result->placeables[i].pos.y)) {
free(result->tiles);
free(result->trees);
log_error("Failed to read tree pos.y from map file.");
free(result->placeables);
log_error("Failed to read placeable pos.y from map file.");
return false;
}
}
@@ -671,8 +676,8 @@ static bool load_map(const char *name, Map *result) {
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");
if (result->num_placeables) {
result->placeables_buffer = renderer_buffer_create(R_BUFFER_USAGE_VERTEX, result->num_placeables * sizeof(*result->placeables), result->placeables, "placeables_buffer");
}
SDL_Log("Loaded map file.");
@@ -928,64 +933,70 @@ 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 *));
static bool recreate_placeable_textures() {
smol_atlas_t *placeable_atlas = sma_atlas_create(PLACEABLE_ATLAS_SIZE, PLACEABLE_ATLAS_SIZE);
smol_atlas_item_t **placeable_atlas_items = (smol_atlas_item_t **)SDL_calloc(SDL_arraysize(placeable_infos), sizeof(smol_atlas_item_t *));
defer(sma_atlas_destroy(tree_atlas));
defer(SDL_free(tree_atlas_items));
defer(sma_atlas_destroy(placeable_atlas));
defer(SDL_free(placeable_atlas_items));
for (Uint32 i = 0; i < SDL_arraysize(tree_infos); i++) {
for (Uint32 i = 0; i < SDL_arraysize(placeable_infos); i++) {
char path[256] = ASSETS_PATH;
SDL_strlcat(path, tree_infos[i].asset_path, SDL_arraysize(path));
SDL_strlcat(path, placeable_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])
placeable_atlas_items[i] = sma_item_add(placeable_atlas, width, height);
if (!placeable_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) {
placeable_textures_atlas = renderer_texture_create(R_TEXTURE_FORMAT_RGBA8_UNORM_SRGB, R_TEXTURE_USAGE_SAMPLED, false, PLACEABLE_ATLAS_SIZE, PLACEABLE_ATLAS_SIZE, NULL, "placeable_atlas_texture");
if (!placeable_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) {
placeable_textures_atlas_imgui = renderer_texture_create(R_TEXTURE_FORMAT_RGBA8_UNORM, R_TEXTURE_USAGE_SAMPLED, false, PLACEABLE_ATLAS_SIZE, PLACEABLE_ATLAS_SIZE, NULL, "placeable_atlas_texture imgui");
if (!placeable_textures_atlas_imgui) {
log_error("Failed to create texture.");
return false;
}
for (Uint32 i = 0; i < SDL_arraysize(tree_infos); i++) {
for (Uint32 i = 0; i < SDL_arraysize(placeable_infos); i++) {
char path[256] = ASSETS_PATH;
SDL_strlcat(path, tree_infos[i].asset_path, SDL_arraysize(path));
SDL_strlcat(path, placeable_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;
renderer_texture_destroy(placeable_textures_atlas);
placeable_textures_atlas = NULL;
renderer_texture_destroy(placeable_textures_atlas_imgui);
placeable_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]);
placeable_uvs[i].x = sma_item_x(placeable_atlas_items[i]);
placeable_uvs[i].y = sma_item_y(placeable_atlas_items[i]);
placeable_uvs[i].z = sma_item_x(placeable_atlas_items[i]) + sma_item_width (placeable_atlas_items[i]);
placeable_uvs[i].w = sma_item_y(placeable_atlas_items[i]) + sma_item_height(placeable_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);
placeable_sizes_and_offsets[i].x = (float)width / 32.0f;
placeable_sizes_and_offsets[i].y = (float)height / 32.0f;
placeable_sizes_and_offsets[i].z = placeable_infos[i].visual_offset.x;
placeable_sizes_and_offsets[i].w = placeable_infos[i].visual_offset.y;
renderer_texture_update(placeable_textures_atlas, sma_item_x(placeable_atlas_items[i]), sma_item_y(placeable_atlas_items[i]), sma_item_width(placeable_atlas_items[i]), sma_item_height(placeable_atlas_items[i]), data, sma_item_width(placeable_atlas_items[i]) * 4);
renderer_texture_update(placeable_textures_atlas_imgui, sma_item_x(placeable_atlas_items[i]), sma_item_y(placeable_atlas_items[i]), sma_item_width(placeable_atlas_items[i]), sma_item_height(placeable_atlas_items[i]), data, sma_item_width(placeable_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");
placeable_uvs_buffer = renderer_buffer_create(R_BUFFER_USAGE_STORAGE, sizeof(placeable_uvs), placeable_uvs, "placeable_uvs_buffer");
placeable_sizes_and_offsets_buffer = renderer_buffer_create(R_BUFFER_USAGE_STORAGE, sizeof(placeable_sizes_and_offsets), placeable_sizes_and_offsets, "placeable_sizes_and_offsets_buffer");
return true;
}
@@ -1117,8 +1128,8 @@ static bool init_resources() {
return false;
}
if (!recreate_tree_textures()) {
log_error("Failed to create tree textures.");
if (!recreate_placeable_textures()) {
log_error("Failed to create placeable textures.");
return false;
}
@@ -1189,46 +1200,46 @@ 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;
if (selected_placeable != -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_placeable = -1;
for (Sint32 i = 0; i < current_map->num_placeables; i++) {
if ((current_map->placeables[i].pos.x == entity_pos.x) && (current_map->placeables[i].pos.y == entity_pos.y)) {
found_placeable = 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;
if (found_placeable != -1) {
Placeable tmp = current_map->placeables[found_placeable];
SDL_memmove(&current_map->placeables[found_placeable], &current_map->placeables[found_placeable + 1], (current_map->num_placeables - (found_placeable + 1)) * sizeof(*current_map->placeables));
current_map->placeables[current_map->num_placeables - 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] = {
current_map->placeables = (Placeable *)SDL_realloc(current_map->placeables, (current_map->num_placeables + 1) * sizeof(*current_map->placeables));
current_map->placeables[current_map->num_placeables] = {
.pos = entity_pos,
.kind = (Uint32)selected_tree,
.kind = (Uint32)selected_placeable,
};
current_map->num_trees++;
current_map->num_placeables++;
}
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; });
std::stable_sort(&current_map->placeables[0], &current_map->placeables[current_map->num_placeables], [](const Placeable &a, const Placeable &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 (current_map->placeables_buffer) renderer_buffer_destroy(current_map->placeables_buffer);
current_map->placeables_buffer = renderer_buffer_create(R_BUFFER_USAGE_VERTEX, current_map->num_placeables * sizeof(*current_map->placeables), current_map->placeables, "placeables_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--;
if (show_placeable_editor && selected_placeable == -1) {
for (Sint32 i = 0; i < current_map->num_placeables; i++) {
if ((current_map->placeables[i].pos.x == entity_pos.x) && (current_map->placeables[i].pos.y == entity_pos.y)) {
SDL_memmove(&current_map->placeables[i], &current_map->placeables[i + 1], (current_map->num_placeables - (i + 1)) * sizeof(*current_map->placeables));
current_map->num_placeables--;
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 (current_map->placeables_buffer) renderer_buffer_destroy(current_map->placeables_buffer);
if (current_map->num_placeables) current_map->placeables_buffer = renderer_buffer_create(R_BUFFER_USAGE_VERTEX, current_map->num_placeables * sizeof(*current_map->placeables), current_map->placeables, "placeables_buffer");
}
if (selected_tile_kind != -1) {
@@ -1345,7 +1356,7 @@ static void update_state_editor() {
if (ImGui::BeginMenu("File")) {
if (ImGui::MenuItem("Reload")) {
recreate_tile_textures();
recreate_tree_textures();
recreate_placeable_textures();
}
if (ImGui::MenuItem("Save")) {
@@ -1366,7 +1377,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::MenuItem("Placeables", NULL, &show_placeable_editor);
ImGui::MenuItem("Worlds", NULL, &show_world_editor);
ImGui::EndMenu();
}
@@ -1382,7 +1393,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::DockBuilderDockWindow("Placeables", left_dock);
ImGui::DockBuilderDockWindow("Worlds", left_dock);
ImGui::DockBuilderFinish(main_viewport_dock);
}
@@ -1502,26 +1513,28 @@ static void update_state_editor() {
selected_tile_kind = -1;
}
if (show_tree_editor) {
if (ImGui::Begin("Trees", &show_tree_editor, ImGuiWindowFlags_NoFocusOnAppearing)) {
if (SelectableImage("##tree", tree_textures_atlas_imgui, ImVec2(64, 64), vec2(0, 0), vec2(0, 0), selected_tree == -1))
selected_tree = -1;
if (show_placeable_editor) {
if (ImGui::Begin("Placeables", &show_placeable_editor, ImGuiWindowFlags_NoFocusOnAppearing)) {
if (SelectableImage("##placeable", placeable_textures_atlas_imgui, ImVec2(64, 64), vec2(0, 0), vec2(0, 0), selected_placeable == -1))
selected_placeable = -1;
for (int i = 0; i < SDL_arraysize(tree_infos); i++) {
for (int i = 0; i < SDL_arraysize(placeable_infos); i++) {
ImGui::PushID(i);
if (i != 0)
SameLineOrWrap(ImVec2(64, 1));
vec2 size = placeable_sizes_and_offsets[i].xy() * 32.0f;
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;
if (i != 0)
SameLineOrWrap(ImVec2(size.x, 1));
if (SelectableImage("##placeable", placeable_textures_atlas_imgui, ImVec2(size.x, size.y), placeable_uvs[i].xy() / (float)PLACEABLE_ATLAS_SIZE, placeable_uvs[i].zw() / (float)PLACEABLE_ATLAS_SIZE, selected_placeable == i))
selected_placeable = i;
ImGui::PopID();
}
}
ImGui::End();
} else {
selected_tree = -1;
selected_placeable = -1;
}
auto add_world_modal = ImGui::GetID("Add World");
@@ -1680,16 +1693,18 @@ 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 },
if (current_map->num_placeables) {
ZoneScopedN("Draw Placeables");
renderer_frame_set_shader(R_SHADER_PLACEABLE);
renderer_frame_draw(NULL, NULL, current_map->placeables_buffer, 6, current_map->num_placeables, &(R_Draw_Resources){
.vertex_storage_buffers = (R_Buffer[]){ placeable_sizes_and_offsets_buffer },
.vertex_uniform_buffers = (R_Buffer[]){ view_projection_matrix_buffer, per_frame_buffer },
.num_vertex_uniform_buffers = 2,
.num_vertex_storage_buffers = 1,
.num_vertex_uniform_buffers = 2,
.fragment_sampled_textures = (R_Texture[]){ tree_textures_atlas },
.fragment_storage_buffers = (R_Buffer[]){ tree_uvs_buffer },
.fragment_sampled_textures = (R_Texture[]){ placeable_textures_atlas },
.fragment_storage_buffers = (R_Buffer[]){ placeable_uvs_buffer },
.fragment_uniform_buffers = (R_Buffer[]){ tint_color_buffer },
.num_fragment_sampled_textures = 1,
@@ -1897,16 +1912,18 @@ 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 },
if (current_map->num_placeables) {
ZoneScopedN("Draw Placeables");
renderer_frame_set_shader(R_SHADER_PLACEABLE);
renderer_frame_draw(NULL, NULL, current_map->placeables_buffer, 6, current_map->num_placeables, &(R_Draw_Resources){
.vertex_storage_buffers = (R_Buffer[]){ placeable_sizes_and_offsets_buffer },
.vertex_uniform_buffers = (R_Buffer[]){ view_projection_matrix_buffer, per_frame_buffer },
.num_vertex_uniform_buffers = 2,
.num_vertex_storage_buffers = 1,
.num_vertex_uniform_buffers = 2,
.fragment_sampled_textures = (R_Texture[]){ tree_textures_atlas },
.fragment_storage_buffers = (R_Buffer[]){ tree_uvs_buffer },
.fragment_sampled_textures = (R_Texture[]){ placeable_textures_atlas },
.fragment_storage_buffers = (R_Buffer[]){ placeable_uvs_buffer },
.fragment_uniform_buffers = (R_Buffer[]){ tint_color_buffer },
.num_fragment_sampled_textures = 1,