diff options
Diffstat (limited to 'src/client')
60 files changed, 3354 insertions, 1608 deletions
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt new file mode 100644 index 0000000..e6994ab --- /dev/null +++ b/src/client/CMakeLists.txt @@ -0,0 +1,60 @@ +cmake_minimum_required(VERSION 3.18) + +project(blockgame_linux) + +file (GLOB_RECURSE SOURCE_FILES CONFIGURE_DEPENDS + "*.cc" +) +file (GLOB_RECURSE HEADER_FILES CONFIGURE_DEPENDS + "*.hh" + "../server/*.hh" + "../shared/*.hh" +) +add_executable(${PROJECT_NAME} + ${SOURCE_FILES} +) + +find_library(LIB_SDL2 sdl2 SDL2 REQUIRED) +find_library(LIB_EPOXY epoxy epoxy EPOXY libepoxy REQUIRED) +find_library(LIB_SQLITE3 sqlite3 SQLITE3 REQUIRED) +find_library(LIB_FREETYPE freetype libfreetype REQUIRED) +find_library(LIB_ASSIMP assimp libassimp REQUIRED) +find_library(LIB_PROTOBUF protobuf libprotobuf REQUIRED) +find_package(Boost COMPONENTS iostreams REQUIRED) +find_package(Threads REQUIRED) +find_package(Backtrace REQUIRED) +find_package(Freetype REQUIRED) + +target_compile_options(${PROJECT_NAME} PRIVATE + -Wall -Wextra -Wshadow -Wdouble-promotion -Wformat=2 -Wundef -fno-common + -Wconversion -Wpedantic -std=c++20 -O2 + -Wno-exceptions + -Wno-missing-field-initializers -Wno-unknown-pragmas +) +target_compile_options(${PROJECT_NAME} PRIVATE + -fstack-protector-strong -fno-omit-frame-pointer #-fsanitize=undefined -fsanitize-trap=undefined +) +target_link_options(${PROJECT_NAME} PRIVATE + -fstack-protector-strong #-fsanitize=undefined -fsanitize-trap=undefined +) +target_include_directories(${PROJECT_NAME} PRIVATE + "../../src" + ${FREETYPE_INCLUDE_DIRS} +) +target_link_libraries(${PROJECT_NAME} PRIVATE + ${LIB_SDL2} + ${LIB_EPOXY} + ${LIB_FREETYPE} + ${LIB_ASSIMP} + ${LIB_PROTOBUF} + ${LIB_SQLITE3} + ${Backtrace_LIBRARIES} + ${Threads_LIBRARIES} + ${Boost_LIBRARIES} + ${FREETYPE_LIBRARIES} + shared + server +) +target_precompile_headers(${PROJECT_NAME} PRIVATE + ${HEADER_FILES} +) diff --git a/src/client/client.cc b/src/client/client.cc index b4cacdc..28b3163 100644 --- a/src/client/client.cc +++ b/src/client/client.cc @@ -1,29 +1,29 @@ #include "client.hh" namespace { -bool should_send_move = false; // Ratelimit move packets by player packets. +std::queue<proto::chunk> received_chunks; -shared::world::block last_block = shared::world::block::type::dirt; - -client::world::chunk::map chunks{4096, shared::world::chunk::hash, - shared::world::chunk::equal}; - -client::players players; } // namespace namespace client { -static auto get_player_it(const std::uint32_t index) { - return std::ranges::find_if( - ::players, [&](const auto& player) { return player.index == index; }); +static shared::net::connection make_connection(const std::string_view address, + const std::string_view port) { + constexpr addrinfo hints = {.ai_flags = AI_PASSIVE, + .ai_family = AF_INET, + .ai_socktype = SOCK_STREAM}; + const auto info = shared::net::get_addr_info(address, port, &hints); + const auto sock = shared::net::make_socket(info.get()); + shared::net::connect_socket(sock, info.get()); + return shared::net::connection(sock); } static proto::packet -make_get_chunk_packet(const shared::math::coords& coords) noexcept { +make_request_chunk_packet(const shared::math::coords& coords) noexcept { proto::packet packet; const auto chunk_packet = packet.mutable_request_chunk_packet(); - shared::net::set_coords(*chunk_packet->mutable_chunk_pos(), coords); + shared::net::set_coords(chunk_packet->mutable_chunk_pos(), coords); return packet; } @@ -39,14 +39,16 @@ static proto::packet make_auth_packet(const std::string& username, return packet; } -static proto::packet make_add_block_packet(const shared::math::coords& coords, - const glm::ivec3& pos) noexcept { +static proto::packet +make_add_block_packet(const shared::math::coords& coords, const glm::ivec3& pos, + const std::uint32_t& active) noexcept { proto::packet packet; - const auto interact_packet = packet.mutable_add_block_packet(); - shared::net::set_coords(*interact_packet->mutable_chunk_pos(), coords); - shared::net::set_ivec3(*interact_packet->mutable_block_pos(), pos); - interact_packet->set_block(static_cast<std::uint32_t>(::last_block.type)); + const auto add_block_packet = packet.mutable_add_block_packet(); + shared::net::set_coords(add_block_packet->mutable_chunk_pos(), coords); + shared::net::set_ivec3(add_block_packet->mutable_block_pos(), pos); + + add_block_packet->set_active_item(active); return packet; } @@ -56,9 +58,9 @@ make_remove_block_packet(const shared::math::coords& coords, const glm::ivec3& pos) noexcept { proto::packet packet; - const auto interact_packet = packet.mutable_remove_block_packet(); - shared::net::set_coords(*interact_packet->mutable_chunk_pos(), coords); - shared::net::set_ivec3(*interact_packet->mutable_block_pos(), pos); + const auto remove_block_packet = packet.mutable_remove_block_packet(); + shared::net::set_coords(remove_block_packet->mutable_chunk_pos(), coords); + shared::net::set_ivec3(remove_block_packet->mutable_block_pos(), pos); return packet; } @@ -69,93 +71,113 @@ make_remove_chunk_packet(const shared::math::coords& coords) noexcept { proto::packet packet; const auto remove_chunk_packet = packet.mutable_remove_chunk_packet(); - shared::net::set_coords(*remove_chunk_packet->mutable_chunk_pos(), coords); + shared::net::set_coords(remove_chunk_packet->mutable_chunk_pos(), coords); + + return packet; +} + +static proto::packet +make_move_packet(const client::moveable& localplayer) noexcept { + proto::packet packet; + + const auto move_packet = packet.mutable_move_packet(); + move_packet->set_commands(localplayer.get_commands()); + shared::net::set_angles(move_packet->mutable_viewangles(), + localplayer.get_angles()); + move_packet->set_active_item(localplayer.get_active_item()); + move_packet->set_sequence(localplayer.get_latest_sequence()); return packet; } static void handle_init_packet(const proto::init& packet) noexcept { - client::state.seed = packet.seed(); - client::state.draw_distance = - std::min(packet.draw_distance(), - client::settings::get({"video", "draw_distance"}, 32)); - auto& localplayer = packet.localplayer(); - client::state.localplayer = localplayer.index(); + // Draw distance is the std::min, but we make it more verbose. + if (const auto& wanted = state::draw_distance = + settings::get({"video", "draw_distance"}, 32); + wanted != packet.draw_distance()) { + + if (wanted < packet.draw_distance()) { + state::draw_distance = wanted; + } else { + shared::print::warn << shared::print::time + << "client: server supported draw_distance (" + << packet.draw_distance() + << ") less than requested (" << wanted << ")\n"; + state::draw_distance = packet.draw_distance(); + } + } + + state::seed = packet.seed(); + state::tickrate = packet.tickrate(); + state::tick = packet.tick(); + state::delta_ticks = 0.0f; // amount of time passed (in ticks) - ::players.emplace_back(shared::net::get_player(localplayer)); + const auto& localplayer = packet.localplayer(); + const auto& index = localplayer.animate().entity().index(); + + state::localplayer_index = index; + state::entities.emplace(index, std::make_unique<player>(localplayer)); } -static void handle_player_packet(const proto::player& packet) noexcept { - if (std::size(::players) <= 0) { +static void +handle_animate_update_packet(const proto::animate_update& packet) noexcept { + const auto& animate = packet.animate(); + const auto& index = animate.entity().index(); + + const auto entity_it = get_entity_it(index); + if (entity_it == std::end(state::entities)) { + state::entities.emplace(index, std::make_unique<player>(animate)); return; } - const auto player_it = get_player_it(packet.index()); + const auto animate_ptr = dynamic_cast<class animate*>(&*entity_it->second); + if (animate_ptr == nullptr) { + return; + } - shared::player player = shared::net::get_player(packet); + const shared::tick_t tick = packet.tick(); - if (player_it == std::end(::players)) { - ::players.emplace_back(player); + // Localplayer updates time factor and is update is called with the sequence + // number instead of the tick. + if (packet.has_sequence()) { + const shared::tick_t sequence = packet.sequence(); + animate_ptr->update_time_factor(sequence, tick); + animate_ptr->notify(animate, sequence, true); return; } - // If the player packet refers to us, we do not override our localplayer's - // commands or viewangles. Also, we should send a new move packet. - if (auto& lp = get_localplayer(::players); lp.index == packet.index()) { - player.viewangles = lp.viewangles; - player.commands = 0u; - ::should_send_move = true; - } - player_it->update(player); + animate_ptr->notify(animate, tick, true); } // Remove the client whose element is equal to pkt.index. -static void handle_remove_packet(const proto::remove_player& packet) noexcept { - const auto player_it = get_player_it(packet.index()); - if (player_it == std::end(::players)) { +static void +handle_remove_entity_packet(const proto::remove_entity& packet) noexcept { + const auto entity_it = get_entity_it(packet.index()); + if (entity_it == std::end(state::entities)) { return; } - ::players.erase(player_it); + + state::entities.erase(entity_it); } static void handle_hear_packet(const proto::hear_player& packet) noexcept { - const auto player_it = get_player_it(packet.index()); - if (player_it == std::end(::players)) { + const auto entity_it = get_entity_it(packet.index()); + if (entity_it == std::end(state::entities)) { return; } - player_it->message.emplace(packet.text()); -} -static void handle_chunk_packet(const proto::chunk& packet) noexcept { - const shared::math::coords pos{.x = packet.chunk_pos().x(), - .z = packet.chunk_pos().z()}; - const auto find_it = ::chunks.find(pos); - if (find_it == std::end(::chunks)) { + const auto player_ptr = dynamic_cast<player*>(&*entity_it->second); + if (player_ptr == nullptr) { return; } - find_it->second.emplace( - client::state.seed, pos, - shared::world::chunk::make_blocks_from_chunk(packet)); - // Force the surrounding chunks to regenerate their vbos. - // It's possible we could only generate the ones that we actually need to - // generate, but that's not really a priority atm. - for (auto x = -1; x <= 1; ++x) { - for (auto z = -1; z <= 1; ++z) { - if (std::abs(x) == 1 && std::abs(z) == 1) { - continue; - } - const auto find_update_it = - ::chunks.find(pos + shared::math::coords{x, z}); - if (find_update_it == std::end(::chunks)) { - continue; - } - if (!find_update_it->second.has_value()) { - continue; - } - find_update_it->second->should_regenerate_vbo = true; - } - } + + player_ptr->message.emplace(packet.text()); +} + +static void handle_chunk_packet(proto::chunk& packet) noexcept { + // Ratelimited parsing, moved into a vector. + ::received_chunks.push(std::move(packet)); } static void @@ -165,81 +187,111 @@ handle_server_message_packet(const proto::server_message& packet) noexcept { "client: received " + std::string{fatal ? "fatal" : ""} + " message from the server \"" + packet.message() + "\"\n"; if (!fatal) { - shared::print::notify(message); + shared::print::notify << shared::print::time << message; return; } - shared::print::warn(message); + shared::print::warn << shared::print::time << message; shared::should_exit = true; } -static void parse_packet(const proto::packet& packet) noexcept { - +static void parse_packet(proto::packet&& packet) noexcept { if (packet.has_init_packet()) { handle_init_packet(packet.init_packet()); - } else if (packet.has_player_packet()) { - handle_player_packet(packet.player_packet()); - } else if (packet.has_remove_player_packet()) { - handle_remove_packet(packet.remove_player_packet()); + } else if (packet.has_animate_update_packet()) { + handle_animate_update_packet(packet.animate_update_packet()); + } else if (packet.has_remove_entity_packet()) { + handle_remove_entity_packet(packet.remove_entity_packet()); } else if (packet.has_hear_player_packet()) { handle_hear_packet(packet.hear_player_packet()); } else if (packet.has_chunk_packet()) { - handle_chunk_packet(packet.chunk_packet()); + handle_chunk_packet(*packet.mutable_chunk_packet()); } else if (packet.has_server_message_packet()) { handle_server_message_packet(packet.server_message_packet()); } #ifndef NDEBUG else { - shared::print::warn("client: unhandled packet type\n"); + shared::print::warn << shared::print::time + << "client: unhandled packet type\n"; } #endif } -static shared::net::connection make_connection(const std::string_view address, - const std::string_view port) { - constexpr addrinfo hints = {.ai_flags = AI_PASSIVE, - .ai_family = AF_INET, - .ai_socktype = SOCK_STREAM}; - const auto info = shared::net::get_addr_info(address, port, &hints); - const auto sock = shared::net::make_socket(info.get()); - shared::net::connect_socket(sock, info.get()); - return shared::net::connection(sock); +static void regenerate_surrounding_chunks(const shared::math::coords& pos) { + // Force the surrounding chunks to regenerate their vbos. + // It's possible we could only generate the ones that we actually need + // to generate, but that's not really a priority atm. + for (auto x = -1; x <= 1; ++x) { + for (auto z = -1; z <= 1; ++z) { + if (std::abs(x) == 1 && std::abs(z) == 1) { + continue; + } + const auto find_update_it = + state::chunks.find(pos + shared::math::coords{x, z}); + if (find_update_it == std::end(state::chunks)) { + continue; + } + if (!find_update_it->second.has_value()) { + continue; + } + find_update_it->second->should_regenerate_vbo = true; + } + } } -static void update_chunks(shared::net::connection& connection) noexcept { +static void parse_new_chunks() { + // Add new chunks. We have to ratelimit these because the server responds + // so quickly that our frametime dives as it parses these new chunk packets. + constexpr int CHUNKS_PER_FRAME = 1; + for (int i = 0; i < CHUNKS_PER_FRAME && !::received_chunks.empty(); + ++i, ::received_chunks.pop()) { - const auto draw_distance = client::state.draw_distance; - const shared::math::coords& lp_pos = get_localplayer(::players).chunk_pos; + const proto::chunk& packet = ::received_chunks.front(); + const shared::math::coords pos{packet.chunk_pos().x(), + packet.chunk_pos().z()}; - // Remove bad chunks. - std::erase_if(::chunks, [&](const auto& chunk) { - const bool should_erase = - !shared::math::is_inside_draw(chunk.first, lp_pos, draw_distance); + const auto find_it = state::chunks.find(pos); + if (find_it == std::end(state::chunks)) { + continue; + } + find_it->second.emplace(state::seed, packet); + regenerate_surrounding_chunks(pos); + } +} + +static void erase_bad_chunks(const shared::math::coords& lp_pos) { + const auto draw_distance = state::draw_distance; + std::erase_if(state::chunks, [&](const auto& chunk) { + const bool should_erase = !shared::math::coords::is_inside_draw( + chunk.first, lp_pos, draw_distance); if (should_erase) { - connection.rsend_packet(make_remove_chunk_packet(chunk.first)); + state::connection->rsend_packet( + make_remove_chunk_packet(chunk.first)); } return should_erase; }); +} - for (int dist = 0; dist <= client::state.draw_distance; ++dist) { +static void request_new_chunks(const shared::math::coords& lp_pos) { + for (int dist = 0; dist <= state::draw_distance; ++dist) { + const auto draw_distance = state::draw_distance; const auto maybe_add_chunk = [&](const int x, const int z) -> bool { const auto pos = shared::math::coords{x + lp_pos.x, z + lp_pos.z}; - if (!is_inside_draw(pos, lp_pos, draw_distance)) { + if (!shared::math::coords::is_inside_draw(pos, lp_pos, + draw_distance)) { return false; } - if (::chunks.contains(pos)) { + if (state::chunks.contains(pos)) { return false; } - connection.rsend_packet(make_get_chunk_packet(pos)); - ::chunks.emplace(pos, std::nullopt); + state::connection->rsend_packet(make_request_chunk_packet(pos)); + state::chunks.emplace(pos, std::nullopt); return true; }; int x = -dist; int z = dist; - - // Does a spiral pattern, but it's basically unnoticable :( for (int i = 0; i < dist * 2 + 1; ++i) { if (maybe_add_chunk(x, z)) { return; @@ -267,125 +319,162 @@ static void update_chunks(shared::net::connection& connection) noexcept { } } -static void update_state() noexcept { - client::state.player_count = ::players.size(); - client::state.requested_chunk_count = - static_cast<std::uint32_t>(std::ranges::count_if( - ::chunks, [](const auto& c) { return !c.second.has_value(); })); - client::state.networked_chunk_count = - std::size(::chunks) - client::state.requested_chunk_count; -} - -static proto::packet make_say_packet(const std::string& text) noexcept { - proto::packet packet; - - const auto sub_say_packet = packet.mutable_say_packet(); - sub_say_packet->set_text(text); +static void update_chunks() { + parse_new_chunks(); - return packet; -} - -// unfortunate non-static :( -void send_say_packet(const std::string& text) noexcept { - client::state.connection->rsend_packet(make_say_packet(text)); + const shared::math::coords& lp_pos = get_localplayer().get_chunk_pos(); + erase_bad_chunks(lp_pos); + request_new_chunks(lp_pos); } static void handle_button_input() noexcept { - if (input::is_key_pressed(SDLK_z)) { - client::render::camera::get_xfov() = 30.0f; - } else { - client::render::camera::get_xfov() = - client::settings::get({"gameplay", "fov"}, 100.0f); - } // Don't build our movement commands if we're inputting text. if (input::state.typing) { return; } - auto& lp = get_localplayer(::players); - using spm = shared::player::mask; - lp.commands |= spm::forward * input::is_key_pressed(SDLK_w); - lp.commands |= spm::left * input::is_key_pressed(SDLK_a); - lp.commands |= spm::backward * input::is_key_pressed(SDLK_s); - lp.commands |= spm::right * input::is_key_pressed(SDLK_d); - lp.commands |= spm::jump * input::is_key_pressed(SDLK_SPACE); - lp.commands |= spm::crouch * input::is_key_pressed(SDLK_LCTRL); - lp.commands |= spm::sprint * input::is_key_pressed(SDLK_LSHIFT); - lp.commands |= spm::attack * input::is_key_pressed(SDL_BUTTON_LEFT); + auto& commands = get_localplayer().get_mutable_commands(); + commands |= spm::forward * input::is_key_pressed(SDLK_w); + commands |= spm::left * input::is_key_pressed(SDLK_a); + commands |= spm::backward * input::is_key_pressed(SDLK_s); + commands |= spm::right * input::is_key_pressed(SDLK_d); + commands |= spm::jump * input::is_key_pressed(SDLK_SPACE); + commands |= spm::crouch * input::is_key_pressed(SDLK_LCTRL); + commands |= spm::sprint * input::is_key_pressed(SDLK_LSHIFT); + commands |= spm::attack * input::is_key_pressed(SDL_BUTTON_LEFT); } static void update_input() noexcept { - client::input::update(); + input::update(); + + if (input::is_key_pressed(SDLK_z)) { + render::camera::get_xfov() = 30.0f; + } else { + render::camera::get_xfov() = settings::get({"gameplay", "fov"}, 100.0f); + } - if (!client::window::is_open()) { + if (!window::is_open()) { handle_button_input(); } - if (client::input::state.quit) { + if (input::state.quit) { shared::should_exit = true; } } -static proto::packet -make_move_packet(const shared::player& localplayer) noexcept { - proto::packet packet; +static void update_delta_ticks() noexcept { + static shared::time_point_t last = std::chrono::steady_clock::now(); - const auto move_packet = packet.mutable_move_packet(); - move_packet->set_commands(localplayer.commands); - shared::net::set_angles(*move_packet->mutable_viewangles(), - localplayer.viewangles); + const auto now = std::chrono::steady_clock::now(); + const auto delta_ticks = + shared::get_duration_seconds(now - last) / + shared::get_duration_seconds(state::get_time_per_tick()); - return packet; + state::delta_ticks += state::time_factor * delta_ticks; + + last = now; } -static void send_move_packet(shared::net::connection& connection) noexcept { - const auto& localplayer = get_localplayer(::players); - connection.usend_packet(make_move_packet(localplayer)); +static void update_pre_move() { + state::player_count = state::entities.size(); + state::requested_chunk_count = static_cast<std::uint32_t>( + std::ranges::count_if(state::chunks, [](const auto& c) { + return !c.second.has_value(); + })); + state::networked_chunk_count = + std::size(state::chunks) - state::requested_chunk_count; + update_delta_ticks(); + update_input(); + update_chunks(); } -static void update_players() noexcept { - const auto lp_index = get_localplayer(::players).index; +static void interp_entities() { + for (auto& [index, entity] : state::entities) { + const auto animate_ptr = dynamic_cast<animate*>(&*entity); + if (animate_ptr == nullptr) { + continue; + } + animate_ptr->interpolate(); + } +} + +static void remove_bad_entities() { + const auto lp_index = *state::localplayer_index; // pvs, remove clients outside of chunks we own - std::erase_if(::players, [&](const auto& player) { - if (player.index == lp_index) { + std::erase_if(state::entities, [&](const auto& pair) { + const auto& [idx, entity] = pair; + + const auto player_ptr = dynamic_cast<const player*>(&*entity); + if (player_ptr == nullptr) { + return false; + } + + if (player_ptr->get_index() == lp_index) { return false; } // Players should be removed if the chunk can't draw. - const auto chunk_it = ::chunks.find(player.chunk_pos); - if (chunk_it == std::end(::chunks)) { + const auto chunk_it = state::chunks.find(player_ptr->get_chunk_pos()); + if (chunk_it == std::end(state::chunks)) { return true; } const auto& chunk = chunk_it->second; - if (!chunk.has_value()) { - return false; - } - - if (!chunk->can_draw()) { + if (chunk.has_value() && !chunk->can_draw()) { return true; } return false; }); } +static void update_entities() noexcept { + interp_entities(); + remove_bad_entities(); +} + +static void update_post_move() { update_entities(); } + +static void maybe_send_move() noexcept { + + // An unknown amount of time has passed since we last rendered and this may + // be more than one tick. We do nothing if it's less than one tick. + const auto num_ticks_passed = static_cast<unsigned>(state::delta_ticks); + + if (num_ticks_passed <= 0) { + return; + } + + // Extrapolate for the number of ticks passed. + auto& localplayer = get_localplayer(); + for (auto i = 0u; i < num_ticks_passed; ++i) { + ++state::tick; // possibly after? + state::delta_ticks -= 1.0f; + localplayer.extrapolate(); + ++localplayer.get_mutable_latest_sequence(); + state::connection->usend_packet(make_move_packet(localplayer)); + } + + // reset all commands except for flying, more later probably + const auto retained = shared::animate::flying; + localplayer.get_mutable_commands() &= retained; +} + // requires SDL_MOUSEMOTION static void handle_mousemotion(const SDL_Event& event) noexcept { const float sens = settings::get<float>({"gameplay", "mouse_sensitivity"}, 0.0235f); - auto& lp = get_localplayer(::players); - auto& angles = lp.viewangles; + auto& lp = get_localplayer(); + auto& angles = lp.get_mutable_angles(); const float pitch_offset = static_cast<float>(event.motion.yrel) * sens; const float yaw_offset = static_cast<float>(event.motion.xrel) * sens; - angles.pitch = std::clamp(angles.pitch - glm::radians(pitch_offset), - glm::radians(-89.0f), glm::radians(89.0f)); - angles.yaw = - std::fmod(angles.yaw + glm::radians(yaw_offset), glm::radians(360.0f)) + - (angles.yaw < 0.0f) * glm::radians(360.0f); + angles.pitch -= glm::radians(pitch_offset); + angles.yaw += glm::radians(yaw_offset); + angles.normalise(); + angles.clamp(); } // requires SDL_MOUSEBUTTONDOWN @@ -395,37 +484,93 @@ static void handle_mousebuttons(const SDL_Event& event) noexcept { return; } + auto& lp = get_localplayer(); const auto mode = event.button.button == SDL_BUTTON_LEFT - ? client::movement::interact_mode::remove - : client::movement::interact_mode::add; - - const auto position = - client::movement::interact(get_localplayer(::players), mode, ::chunks); - + ? movement::interact_mode::remove + : movement::interact_mode::add; + const auto position = movement::interact(lp, mode, state::chunks); if (!position.has_value()) { return; } const auto& [chunk_pos, block_pos] = *position; + auto& block = state::chunks.find(chunk_pos)->second->get_block(block_pos); + + if (mode == movement::interact_mode::remove) { + lp.inventory.maybe_add(shared::item::block::get_type(block.type), 1, + client::item::make_item); + block.type = shared::world::block::type::air; + + state::connection->rsend_packet( + make_remove_block_packet(chunk_pos, block_pos)); + } else { + // Adding is more complicated, needs the active item. + const auto& active = lp.get_active_item(); + auto& item = lp.inventory.contents[active]; + if (item == nullptr) { + return; + } + + const auto block_ptr = dynamic_cast<const shared::item::block*>(&*item); + if (block_ptr == nullptr) { + return; + } + lp.inventory.decrement(active); + block.type = block_ptr->type; + + state::connection->rsend_packet( + make_add_block_packet(chunk_pos, block_pos, active)); + } + + regenerate_surrounding_chunks(chunk_pos); +} - auto& connection = *client::state.connection; - switch (mode) { - case client::movement::interact_mode::add: - connection.usend_packet(make_add_block_packet(chunk_pos, block_pos)); +static void handle_space(const SDL_Event& event) noexcept { + if (event.type == SDL_KEYUP) { + return; + } + auto& commands = get_localplayer().get_mutable_commands(); + commands |= shared::animate::mask::jump; + + if (event.key.repeat) { + return; + } + constexpr auto JUMP_FLY_DELAY = std::chrono::milliseconds(250); + + static std::optional<shared::time_point_t> prev = std::nullopt; + const auto now = std::chrono::steady_clock::now(); + if (prev.has_value() && now < *prev + JUMP_FLY_DELAY) { + commands ^= shared::animate::mask::flying; + prev.reset(); + return; + } + + prev.emplace(now); +} + +static void handle_keys(const SDL_Event& event) noexcept { + switch (event.key.keysym.sym) { + case SDLK_SPACE: + handle_space(event); break; - case client::movement::interact_mode::remove: - connection.usend_packet(make_remove_block_packet(chunk_pos, block_pos)); - ::last_block = ::chunks[chunk_pos]->get_block(block_pos); + default: break; } } static void handle_events(const SDL_Event& event) noexcept { - if (client::window::is_open()) { + if (window::is_open()) { + return; + } + if (!state::localplayer_index.has_value()) { return; } switch (event.type) { + case SDL_KEYDOWN: + case SDL_KEYUP: + handle_keys(event); + break; case SDL_MOUSEBUTTONDOWN: handle_mousebuttons(event); break; @@ -437,79 +582,124 @@ static void handle_events(const SDL_Event& event) noexcept { } } -static void authenticate_client(shared::net::connection& connection) noexcept { - const auto rand_alphanum_string = [](const int size) -> std::string { - static const std::string allowed = "abcdefghijklmnopqrstuvwxyz" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "1234567890"; - std::string ret; - for (int i = 0; i < size; ++i) { - std::ranges::sample(allowed, std::back_inserter(ret), 1, - std::random_device{}); - } +static std::string get_username() { + const settings::setting_pair_t loc = {"gameplay", "username"}; + if (const auto username = settings::maybe_get_setting_str(loc); + username.has_value()) { + return *username; + } - return ret; - }; + shared::print::notify << shared::print::time + << "first launch detected, username required\n"; + std::string ret; + while (ret.empty() || !std::ranges::all_of(ret, isalnum)) { + std::cin.clear(); + std::cout << "enter a valid username: "; + std::getline(std::cin, ret); + } + settings::set_setting_str(loc, ret); + return ret; +} - const std::string username = settings::get<std::string>( - {"auth", "username"}, - rand_alphanum_string(shared::MAX_USER_PASS_LENGTH)); - const std::string password = settings::get<std::string>( - {"auth", "password"}, - rand_alphanum_string(shared::MAX_USER_PASS_LENGTH)); +static std::string get_password(const std::string_view& address) { + const settings::setting_pair_t loc = { + "auth", std::string{address == "0.0.0.0" ? "localhost" : address}}; + if (const auto password = settings::maybe_get_setting_str(loc); + password.has_value()) { + return *password; + } - connection.rsend_packet(make_auth_packet(username, password)); + // We generate a random string as our password. Our password has decent + // complexitity but considering we don't use any encryption it is worthless + // to any real attacker and just basic authentication. + std::string ret; + std::random_device rand{}; + std::uniform_int_distribution<char> uniform{'a', 'z'}; + for (int i = 0; i < 256; ++i) { + const char random_char = uniform(rand); + ret.push_back(random_char); + } + settings::set_setting_str(loc, ret); + return ret; } -void main(const std::string_view address, const std::string_view port) { - client::state.address = address; - client::state.port = port; +static void send_auth_packet(const std::string_view& address, + shared::net::connection& connection) { + const std::string username = get_username(); + const std::string password = get_password(address); - shared::net::connection connection = make_connection(address, port); - shared::print::notify("client: connected to " + std::string{address} + ':' + - std::string{port} + '\n'); - client::state.connection = &connection; + connection.rsend_packet(make_auth_packet(username, password)); +} + +static bool should_do_loop(shared::net::connection& connection) noexcept { + if (shared::should_exit) { + return false; + } - client::render::init(); - client::input::register_event_handler(&handle_events); + if (!connection.good()) { + shared::print::notify << shared::print::time + << "client: disconnected for \"" + << connection.get_bad_reason() << "\"\n"; + shared::should_exit = true; // cleanup server if necessary + return false; + } - authenticate_client(connection); + return true; +} - while (!shared::should_exit) { - // Parse all new packets. - while (const auto packet = connection.recv_packet()) { - parse_packet(packet.value()); +static void do_client_loop(shared::net::connection& connection) { + while (should_do_loop(connection)) { + connection.poll(); + while (auto packet = connection.recv_packet()) { + parse_packet(std::move(*packet)); } - // Wait for localplayer to be constructed before doing anything. - if (::players.empty()) { + if (!state::has_initialised()) { continue; } - // Handle input, which may prime text input -> send it to the - // server. - update_input(); - // Send our localplayer to the server. - if (::should_send_move) { - send_move_packet(connection); - ::should_send_move = false; - } - update_chunks(connection); - update_state(); - update_players(); - - client::draw::draw(::players, ::chunks); + update_pre_move(); + maybe_send_move(); + update_post_move(); - if (!connection.good()) { - shared::print::notify("client: disconnected for \"" + - connection.get_bad_reason() + "\"\n"); - shared::should_exit = true; - } + render::draw(state::entities, state::chunks); } - shared::print::notify("client: disconnecting from server\n"); +} + +static void init_client(const std::string_view& address, + const std::string_view& port, + shared::net::connection& connection) { + // Setup client state, some vars should be cleaned up later (raii lol). + state::address = address; + state::port = port; + state::connection = &connection; + + input::register_event_handler(&handle_events); + send_auth_packet(address, connection); + + render::init(); +} + +static void cleanup_client() { + state::connection = nullptr; + state::localplayer_index.reset(); + state::chunks.clear(); + state::entities.clear(); + render::quit(); + settings::save(); +} + +void main(const std::string_view address, const std::string_view port) { + shared::net::connection connection = make_connection(address, port); + init_client(address, port, connection); + shared::print::notify << shared::print::time << "client: connected to " + << address << ':' << port << '\n'; + + do_client_loop(connection); - client::render::quit(); - client::settings::save(); + shared::print::notify << shared::print::time + << "client: disconnecting from server\n"; + cleanup_client(); } } // namespace client diff --git a/src/client/client.hh b/src/client/client.hh index 6dbabc1..0eadfe4 100644 --- a/src/client/client.hh +++ b/src/client/client.hh @@ -3,25 +3,30 @@ #include <algorithm> #include <cmath> +#include <queue> +#include <random> #include <string_view> #include <unordered_map> -#include "client/draw.hh" +#include "client/entity/player.hh" #include "client/input.hh" -#include "client/movement.hh" -#include "client/player.hh" +#include "client/item/items.hh" +#include "client/movement/movement.hh" #include "client/render/camera.hh" +#include "client/render/draw.hh" #include "client/settings.hh" #include "client/shared.hh" -#include "client/window.hh" -#include "client/world.hh" -#include "shared/math.hh" +#include "client/state/chunks.hh" +#include "client/state/entities.hh" +#include "client/state/state.hh" +#include "client/window/window.hh" +#include "client/world/chunk.hh" +#include "shared/math/math.hh" +#include "shared/net/connection.hh" #include "shared/net/net.hh" #include "shared/net/proto.hh" namespace client { -void send_say_packet(const std::string& text) noexcept; - void main(const std::string_view address, const std::string_view port); } // namespace client diff --git a/src/client/draw.hh b/src/client/draw.hh deleted file mode 100644 index 821d67b..0000000 --- a/src/client/draw.hh +++ /dev/null @@ -1,59 +0,0 @@ -#ifndef CLIENT_DRAW_HH_ -#define CLIENT_DRAW_HH_ - -#include <string_view> - -#include <glm/glm.hpp> - -#include "client/movement.hh" -#include "client/player.hh" -#include "client/render/camera.hh" -#include "client/render/render.hh" -#include "client/render/program.hh" -#include "client/shared.hh" -#include "client/window.hh" -#include "client/world.hh" - -namespace client { -namespace draw { - -// Scale takes the range [0, 1] and represents an amount of the screen. -// Offset is any value that is added after scale. -struct relative_arg { - glm::vec2 extent; - glm::vec2 offset; - - glm::vec2 to_vec2() const noexcept { - const glm::vec2& window = render::get_window_size(); - const float x = this->extent.x * window.x + this->offset.x; - const float y = this->extent.y * window.y + this->offset.y; - return {x, y}; - } -}; - -struct rectangle_args { - relative_arg pos; - relative_arg size; - glm::vec4 colour; -}; - -struct text_args { - relative_arg pos; - float extent_height; // we don't get width here, - float offset_height; - glm::vec4 colour; - bool has_backing; - bool is_centered; - bool is_vcentered; -}; - -void draw_rectangle(const rectangle_args& args) noexcept; -void draw_colour(const glm::vec4& colour) noexcept; -void draw_text(const std::string_view text, const text_args& args) noexcept; - -void draw(client::players& players, client::world::chunk::map& chunks) noexcept; - -} // namespace draw -} // namespace client - -#endif diff --git a/src/client/entity/animate.cc b/src/client/entity/animate.cc new file mode 100644 index 0000000..9142b55 --- /dev/null +++ b/src/client/entity/animate.cc @@ -0,0 +1,158 @@ +#include "player.hh" + +namespace client { + +// We might start receiving data slower or faster. We compensate by adjusting +// how fast time progresses on our client.; +void animate::update_time_factor(const shared::tick_t& sequence, + const shared::tick_t& tick) noexcept { + + // Check if we're older than the latest, don't update if so. + if (std::ranges::any_of(this->updates, [&](const auto& update) { + return update.from_server && update.tick_sequence >= sequence; + })) { + return; + } + + // How many ticks in the future we prefer to be at. If the server is + // jittery, we would want this value to be greater, but this should be OK + // for most cases. A larger value decreases the max ping we can handle. + constexpr float TARGET_TICKS_AHEAD = 1.341519f; + + if (const auto tick_dist = static_cast<std::int64_t>(tick) - + static_cast<std::int64_t>(state::tick); + tick_dist > 0) { + + // We're behind, jump ahead. We only touch delta_ticks so extrapolate + // is called the correct number of times in client.cc. +#ifndef NDEBUG + shared::print::debug << shared::print::time + << "client: time_factor jumped ahead, got tick " + << tick << ", was " << state::tick << " + " + << state::delta_ticks + << ", time_factor: " << state::time_factor << '\n'; +#endif + state::delta_ticks = static_cast<float>(tick_dist) + TARGET_TICKS_AHEAD; + state::time_factor = 1.0f; + + return; + } + + // Otherwise we try to move towards the value by adjusting how fast time + // progresses. This shouldn't be possible to notice, our constants should + // be adjusted if it is. + const float time_diff = + (static_cast<float>(tick) + TARGET_TICKS_AHEAD) - + (static_cast<float>(state::tick) + state::delta_ticks); + + constexpr float MAX_TIME_FACTOR_DIFF = 0.1f; + constexpr float TIME_FACTOR_AGGRESSIVENESS = 0.25f; + state::time_factor = + std::clamp(1.0f + (time_diff * TIME_FACTOR_AGGRESSIVENESS), + 1.0f - MAX_TIME_FACTOR_DIFF, 1.0f + MAX_TIME_FACTOR_DIFF); +} + +void animate::notify(const shared::animate& animate, + const shared::tick_t& tick_sequence, + const bool from_server) noexcept { + // If it's from the server we want to update previously emplaced predicted + // (and potentially predicted) values. + if (const auto it = std::ranges::find_if(this->updates, + [&](const auto& update) { + return update.tick_sequence == + tick_sequence; + }); + it != std::end(this->updates)) { + + if (from_server) { + *it = animate_update{.tick_sequence = tick_sequence, + .animate = animate, + .from_server = from_server}; + } + + return; + } + + this->updates.push_back({.tick_sequence = tick_sequence, + .animate = animate, + .from_server = from_server}); + + std::ranges::sort(this->updates, [](const auto& a, const auto& b) { + return a.tick_sequence < b.tick_sequence; + }); +} + +float animate::get_target_ticks_back() noexcept { + // The localplayer is interpolated via the latest tick. + const unsigned base_ticks_back = [&]() -> unsigned { + if (this->index == *state::localplayer_index) { + return 0u; + } + const float base = settings::get<float>({"engine", "interp"}, 0.25f); + const float ret = base * static_cast<float>(state::tickrate); + return std::clamp(static_cast<unsigned>(ret), 0u, state::tickrate); + }(); + + return state::delta_ticks + static_cast<float>(base_ticks_back); +} + +void animate::interpolate() noexcept { + const float target_ticks_back = this->get_target_ticks_back(); + + const bool is_localplayer = this->index == *state::localplayer_index; + const auto b_it = [&, this]() { + if (is_localplayer) { + return std::rbegin(this->updates); + } + return std::ranges::find_if( + std::rbegin(this->updates), std::rend(this->updates), + [&](const auto& update) { + const unsigned target = + state::tick - static_cast<unsigned>(target_ticks_back); + return update.tick_sequence <= target; + }); + }(); + if (b_it == std::rend(this->updates)) { + return; + } + + const auto a_it = std::next(b_it); + if (a_it == std::rend(this->updates)) { + return; + } + + const glm::vec3 a_pos = a_it->animate.get_local_pos(); + const glm::vec3 b_pos = shared::movement::make_relative( + a_it->animate.get_chunk_pos(), b_it->animate.get_local_pos(), + b_it->animate.get_chunk_pos()); + + const float b_interp = [&]() { + const float diff = + is_localplayer + ? 1.0f + : static_cast<float>(b_it->tick_sequence - a_it->tick_sequence); + const float base = std::fmod(target_ticks_back, 1.0f); + const float a_dist = diff - (1.0f - base); + return a_dist / diff; + }(); + const float a_interp = (1.0f - b_interp); + + const auto& a = a_it->animate; + const auto& b = b_it->animate; + this->local_pos = a_pos * a_interp + b_pos * b_interp; + this->chunk_pos = a.get_chunk_pos(); + this->velocity = a.get_velocity() * a_interp + b.get_velocity() * b_interp; + // Update viewangles if we're not the localplayer, yaw requires special care + // because it should snap to the closest difference angle. + if (!is_localplayer) { + this->viewangles.pitch = + a.get_angles().pitch * a_interp + b.get_angles().pitch * b_interp; + const float yaw_delta = shared::math::angles::get_yaw_delta( + a.get_angles().yaw, b.get_angles().yaw); + this->viewangles.yaw = a.get_angles().yaw + yaw_delta * b_interp; + this->viewangles.normalise(); + } + shared::movement::normalise_position(this->local_pos, this->chunk_pos); +} + +} // namespace client diff --git a/src/client/entity/animate.hh b/src/client/entity/animate.hh new file mode 100644 index 0000000..79016ea --- /dev/null +++ b/src/client/entity/animate.hh @@ -0,0 +1,71 @@ +#ifndef CLIENT_ENTITY_ANIMATE_HH_ +#define CLIENT_ENTITY_ANIMATE_HH_ + +#include <algorithm> +#include <chrono> +#include <cmath> +#include <ranges> +#include <utility> +#include <vector> + +#include <boost/circular_buffer.hpp> + +#include "client/entity/entity.hh" +#include "client/movement/movement.hh" +#include "client/settings.hh" +#include "client/state/state.hh" +#include "shared/entity/animate.hh" +#include "shared/entity/entity.hh" +#include "shared/movement/movement.hh" +#include "shared/net/proto.hh" +#include "shared/shared.hh" + +namespace client { + +class animate : virtual public shared::animate, virtual public client::entity { +protected: + struct animate_update { + shared::tick_t tick_sequence; // tick or sequence, if LP then sequence. + shared::animate animate; + bool from_server; + }; + + // We have 1 second of potential player interpolation to use here when we + // initialise this with the server's tickrate. + boost::circular_buffer<animate_update> updates{state::tickrate}; + shared::tick_t latest_sequence = 0; + +private: + float get_target_ticks_back() noexcept; + +public: + animate(shared::player&& p) noexcept + : shared::entity(p), shared::animate(p), client::entity(p) {} + + animate(const proto::animate& proto) noexcept + : shared::entity(proto.entity()), shared::animate(proto), + client::entity(proto.entity()) {} + +public: + // Call when localplayer gets tick to update state timers. + void update_time_factor(const shared::tick_t& sequence, + const shared::tick_t& tick) noexcept; + + virtual void notify(const shared::animate& animate, + const shared::tick_t& tick_sequence, + const bool from_server) noexcept; + + shared::tick_t& get_mutable_latest_sequence() noexcept { + return this->latest_sequence; + } + shared::tick_t get_latest_sequence() const noexcept { + return this->latest_sequence; + } + // An animate may be interpolated, however it's the moveable class that is + // required for extrapolation and other prediction. + void interpolate() noexcept; +}; + +} // namespace client + +#endif diff --git a/src/client/entity/entity.cc b/src/client/entity/entity.cc new file mode 100644 index 0000000..c305a66 --- /dev/null +++ b/src/client/entity/entity.cc @@ -0,0 +1,6 @@ +#include "client/entity/entity.hh" + +namespace client { + + +} // namespace client diff --git a/src/client/entity/entity.hh b/src/client/entity/entity.hh new file mode 100644 index 0000000..e8d6cc6 --- /dev/null +++ b/src/client/entity/entity.hh @@ -0,0 +1,27 @@ +#ifndef CLIENT_ENTITY_ENTITY_HH_ +#define CLIENT_ENTITY_ENTITY_HH_ + +#include "shared/entity/entity.hh" +#include "shared/entity/player.hh" + +namespace client { + +class player; // forward declaration + +// A client::entity is a renderable shared::entity. +class entity : virtual public shared::entity { +public: + entity(shared::entity& e) noexcept + : shared::entity(std::forward<shared::entity>(e)) {} + entity(const proto::entity& e) noexcept : shared::entity(e) {} + + virtual ~entity() noexcept {} + +public: + virtual void draw(const client::player& localplayer) noexcept = 0; + virtual void draw_wts(const client::player& localplayer) noexcept = 0; +}; + +} // namespace client + +#endif diff --git a/src/client/entity/moveable.cc b/src/client/entity/moveable.cc new file mode 100644 index 0000000..480e6db --- /dev/null +++ b/src/client/entity/moveable.cc @@ -0,0 +1,86 @@ +#include "client/entity/moveable.hh" + +namespace client { + +static auto find_sequence_it(auto& updates, + const shared::tick_t& sequence) noexcept { + return std::ranges::find_if(updates, [&sequence](const auto& update) { + return update.tick_sequence == sequence; + }); +} + +void moveable::repredict_from(const shared::tick_t& sequence) noexcept { + // find the animate update we want to repredict starting from + const auto find_it = find_sequence_it(this->updates, sequence); + if (find_it == std::end(this->updates)) { + return; + } + + // backup current animate + const shared::animate before_move = *this; + + // predict the next ticks starting from find_it until we run + // out of prediction history + for (auto it = find_it; it != std::end(this->updates); ++it) { + const auto next_it = std::next(it); + if (next_it == std::end(this->updates)) { + break; + } + + const auto viewangles = next_it->animate.get_angles(); + const auto commands = next_it->animate.get_commands(); + + this->shared::animate::operator=(it->animate); + this->commands = commands; + this->viewangles = viewangles; + const auto predicted = movement::move(*this, state::chunks); + if (!predicted.has_value()) { + break; + } + next_it->animate = *predicted; + next_it->animate.get_mutable_angles() = viewangles; + next_it->animate.get_mutable_commands() = commands; + } + // restore current animate + this->shared::animate::operator=(before_move); +} + +void moveable::notify(const shared::animate& animate, + const shared::tick_t& sequence, + const bool from_server) noexcept { + this->animate::notify(animate, sequence, from_server); + + if (!from_server) { // Only repredict if we're from the server. + return; + } + this->repredict_from(sequence); +} + +void moveable::extrapolate() noexcept { + // can't extrapolate if no data + if (this->updates.empty()) { + return; + } + + const auto& latest_it = std::rbegin(this->updates); + if (latest_it == std::rend(this->updates)) { + return; + } + + // backup current animate, load latest animate + const shared::animate before_extrapolate = *this; + this->shared::animate::operator=(latest_it->animate); + + // FIXED: we were writing our commands with the old commands, so we were + // always predicting the first commands, which were always for not moving! + this->commands = before_extrapolate.get_commands(); + this->viewangles = before_extrapolate.get_angles(); + + const auto predicted = movement::move(*this, state::chunks); + if (predicted.has_value()) { + this->notify(*predicted, this->get_latest_sequence() + 1, false); + } + this->shared::animate::operator=(before_extrapolate); +} + +} // namespace client diff --git a/src/client/entity/moveable.hh b/src/client/entity/moveable.hh new file mode 100644 index 0000000..fa08d22 --- /dev/null +++ b/src/client/entity/moveable.hh @@ -0,0 +1,29 @@ +#ifndef CLIENT_ENTITY_MOVEABLE_HH_ +#define CLIENT_ENTITY_MOVEABLE_HH_ + +#include "client/entity/animate.hh" +#include "client/state/chunks.hh" +#include "client/state/state.hh" +#include "client/world/chunk.hh" +#include "shared/entity/moveable.hh" + +namespace client { + +class moveable : virtual public client::animate, + virtual public shared::moveable, + virtual public shared::animate { +private: + void repredict_from(const shared::tick_t& sequence) noexcept; + +public: + // Notify repredicts if necessary. + virtual void notify(const shared::animate& animate, + const shared::tick_t& sequence, + const bool from_server) noexcept override; + + void extrapolate() noexcept; +}; + +} // namespace client + +#endif diff --git a/src/client/entity/player.cc b/src/client/entity/player.cc new file mode 100644 index 0000000..550968f --- /dev/null +++ b/src/client/entity/player.cc @@ -0,0 +1,54 @@ +#include "player.hh" +namespace client { + +glm::vec3 player::get_world_pos(const client::player& lp) noexcept { + const auto& lp_cp = lp.get_chunk_pos(); + + // clang-format off + const float world_x = static_cast<float>(this->get_chunk_pos().x - lp_cp.x) * shared::world::chunk::WIDTH + this->local_pos.x; + const float world_y = static_cast<float>(this->get_local_pos().y) + shared::player::HEIGHT / 2.0f; + const float world_z = static_cast<float>(this->get_chunk_pos().z - lp_cp.z) * shared::world::chunk::WIDTH + this->local_pos.z; + // clang-format on + return {world_x, world_y, world_z}; +} + +void player::draw(const client::player& localplayer) noexcept { + + static render::model playermodel{"res/models/player/player.obj"}; + static render::program program{"res/shaders/model.vs", + "res/shaders/model.fs"}; + + const glm::vec3 world_pos = this->get_world_pos(localplayer); + const glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), -this->viewangles.yaw, + glm::vec3(0.0f, 1.0f, 0.0f)); + const glm::mat4 translate = glm::translate(glm::mat4(1.0f), world_pos); + const glm::mat4& view = render::camera::get_view(); + const glm::mat4& proj = render::camera::get_proj(); + + playermodel.draw(program, proj * view * translate * rotate); +} + +void player::draw_wts(const client::player& localplayer) noexcept { + const auto& msg = this->get_message(); + if (!msg.has_value()) { + return; + } + + const glm::vec3 world_pos = this->get_world_pos(localplayer); + const auto pos = math::world_to_screen(world_pos); + + if (!pos.has_value()) { + return; + } + + const glm::vec2& window = render::get_window_size(); + const glm::mat4 proj = glm::ortho(0.0f, window.x, 0.0f, window.y); + const glm::mat4 tran = + glm::translate(glm::mat4(1.0f), + glm::vec3{std::floor(pos->x), std::floor(pos->y), 0.0f}); + + constexpr glm::vec4 white{1.0f, 1.0f, 1.0f, 1.0f}; + render::render_text(msg->text, 30.0f, true, true, white, proj * tran); +} + +} // namespace client diff --git a/src/client/entity/player.hh b/src/client/entity/player.hh new file mode 100644 index 0000000..d9bdc18 --- /dev/null +++ b/src/client/entity/player.hh @@ -0,0 +1,73 @@ +#ifndef CLIENT_ENTITY_PLAYER_HH_ +#define CLIENT_ENTITY_PLAYER_HH_ + +#include <chrono> +#include <optional> +#include <string> +#include <utility> + +#include "client/entity/moveable.hh" +#include "client/entity/entity.hh" +#include "client/item/block.hh" +#include "client/item/items.hh" +#include "client/math.hh" +#include "client/render/camera.hh" +#include "client/render/model.hh" +#include "client/render/program.hh" + +namespace client { + +// Renderable player, similar to client::chunk. We also store the message the +// player wants to say. +class player : virtual public shared::player, public client::moveable { +public: + static constexpr auto MSG_SHOW_TIME = std::chrono::seconds{15}; + struct message { + std::string text; + std::chrono::time_point<std::chrono::steady_clock> receive_time; + message(const std::string& message) noexcept { + this->text = message; + this->receive_time = std::chrono::steady_clock::now(); + } + }; + std::optional<message> message; + +private: + glm::vec3 get_world_pos(const client::player& lp) noexcept; + +public: + player(shared::player&& p) noexcept + : shared::entity(p), shared::animate(p), shared::player(p), + client::entity(p), client::animate(std::move(p)) { + + // upgrade our inventory contents to client::item::item + for (auto& item : this->inventory.contents) { + if (item == nullptr) { + continue; + } + + item = client::item::make_item(item->get_type(), item->quantity); + } + } + player(const proto::animate& proto) noexcept + : shared::entity(proto.entity()), shared::animate(proto), + shared::player(proto), client::entity(proto.entity()), + client::animate(proto) {} + + virtual void draw(const client::player& localplayer) noexcept override; + virtual void draw_wts(const client::player& localplayer) noexcept override; + + const std::optional<struct message>& get_message() noexcept { + if (this->message.has_value()) { + const auto now = std::chrono::steady_clock::now(); + if (now > this->message->receive_time + player::MSG_SHOW_TIME) { + this->message.reset(); + } + } + return this->message; + } +}; + +} // namespace client + +#endif diff --git a/src/client/item/block.cc b/src/client/item/block.cc new file mode 100644 index 0000000..08f072b --- /dev/null +++ b/src/client/item/block.cc @@ -0,0 +1,91 @@ +#include "client/item/block.hh" + +namespace client { +namespace item { + +void block::regenerate_glo() noexcept { + const auto make_vbo = [](const auto& data) -> GLuint { + GLuint vbo = 0; + glGenBuffers(1, &vbo); + glBindBuffer(GL_ARRAY_BUFFER, vbo); + glBufferData(GL_ARRAY_BUFFER, + std::size(data) * sizeof(client::world::block::glvert), + std::data(data), GL_STATIC_DRAW); + return vbo; + }; + const auto make_vao = []() -> GLuint { + GLuint vao = 0; + glGenVertexArrays(1, &vao); + glBindVertexArray(vao); + // posiiton + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, sizeof(glm::vec3) / sizeof(float), GL_FLOAT, + GL_FALSE, sizeof(client::world::block::glvert), + nullptr); + // texture + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, sizeof(glm::vec3) / sizeof(float), GL_FLOAT, + GL_FALSE, sizeof(client::world::block::glvert), + reinterpret_cast<void*>(sizeof(glm::vec3))); + return vao; + }; + std::vector<client::world::block::glvert> data; + + const float tex_yoff = static_cast<float>(this->type) - 1.0f; + for (const auto& face : + client::world::block::get_glfaces(this->shared::item::block::type)) { + + std::ranges::transform(face, std::back_inserter(data), [&](auto vert) { + vert.texture.z += tex_yoff * 6.0f; + return vert; + }); + } + + const auto vbo = make_vbo(data); + const auto vao = make_vao(); + this->glo.emplace(vbo, vao, std::size(data)); +} + +void block::draw(const glm::vec2& pos, const glm::vec2& size) noexcept { + const auto make_matrix = [&]() -> glm::mat4 { + const glm::vec2 window = client::render::get_window_size(); + + constexpr auto identity = glm::mat4{1.0f}; + const auto proj = glm::ortho(0.0f, window.x, 0.0f, window.y); + const auto scal = + glm::scale(identity, glm::vec3{size.x * 0.5f, size.y * 0.5f, 0.0f}); + const auto tran = + glm::translate(identity, glm::vec3{pos.x + size.x / 2.0f, + pos.y + size.y / 2.0f, 0.0f}); + + // hack for shurbs, which are already offset and look bad when rotated + const auto rotey = client::world::block::get_draw_type(this->type) == + client::world::block::draw_type::block + ? glm::rotate(identity, glm::radians(45.0f), + glm::vec3(0.0f, 1.0f, 0.0f)) + : identity; + const auto rotex = glm::rotate(identity, glm::radians(30.0f), + glm::vec3(1.0f, 0.0f, 0.0f)); + return proj * tran * scal * rotex * rotey; + }; + + static const client::render::program program{"res/shaders/face.vs", + "res/shaders/face.fs"}; + static const GLint u_matrix = glGetUniformLocation(program, "_u_matrix"); + + if (!this->glo.has_value()) { + this->regenerate_glo(); + } + + glDisable(GL_BLEND); + glDisable(GL_DEPTH_TEST); + glUseProgram(program); + glBindVertexArray(this->glo->vao); + + glUniformMatrix4fv(u_matrix, 1, GL_FALSE, glm::value_ptr(make_matrix())); + + glDrawArrays(GL_TRIANGLES, 0, this->glo->elements); +} + +} // namespace item +} // namespace client diff --git a/src/client/item/block.hh b/src/client/item/block.hh new file mode 100644 index 0000000..f259aad --- /dev/null +++ b/src/client/item/block.hh @@ -0,0 +1,58 @@ +#ifndef CLIENT_ITEM_BLOCK_HH_ +#define CLIENT_ITEM_BLOCK_HH_ + +#include <algorithm> +#include <optional> + +#include "client/item/item.hh" +#include "client/render/render.hh" +#include "client/world/block.hh" +#include "shared/item/block.hh" +#include "shared/item/item.hh" + +namespace client { +namespace item { + +class block : virtual public shared::item::block, public client::item::item { +private: + struct gl_object { + GLuint vbo; + GLuint vao; + unsigned long elements; + + gl_object(const GLuint& vbo, const GLuint& vao, + const unsigned long& elements) noexcept + : vbo(vbo), vao(vao), elements(elements) {} + gl_object(const gl_object&) = delete; + gl_object(gl_object&&) = delete; + ~gl_object() noexcept { + glDeleteBuffers(1, &vbo); + glDeleteVertexArrays(1, &vao); + } + }; + +private: + std::optional<gl_object> glo = std::nullopt; + void regenerate_glo() noexcept; + +public: + template <typename... Args> + block(const enum shared::world::block::type& type, Args&&... args) noexcept + : shared::item::block(type, args...), client::item::item( + std::forward<Args>(args)...) { + } + template <typename... Args> + block(const shared::item::item::type_t& type, Args&&... args) noexcept + : shared::item::item(type, args...), shared::item::block(type, args...), + client::item::item(type, std::forward<Args>(args)...) {} + virtual ~block() noexcept {} + +public: + virtual void draw(const glm::vec2& pos, + const glm::vec2& size) noexcept override; +}; + +} // namespace item +} // namespace client + +#endif diff --git a/src/client/item/item.cc b/src/client/item/item.cc new file mode 100644 index 0000000..64cc1f5 --- /dev/null +++ b/src/client/item/item.cc @@ -0,0 +1 @@ +#include "client/item/item.hh" diff --git a/src/client/item/item.hh b/src/client/item/item.hh new file mode 100644 index 0000000..ff80369 --- /dev/null +++ b/src/client/item/item.hh @@ -0,0 +1,30 @@ +#ifndef CLIENT_ITEM_ITEM_HH_ +#define CLIENT_ITEM_ITEM_HH_ + +#include <algorithm> + +#include <glm/glm.hpp> + +#include "shared/item/item.hh" + +namespace client { +namespace item { + +// client::item is a renderiable shared::item +class item : virtual public shared::item::item { +public: +public: + template <typename... Args> + item(Args&&... args) noexcept + : shared::item::item(std::forward<Args>(args)...) {} + virtual ~item() noexcept {} + +public: + // 2d drawing of items + virtual void draw(const glm::vec2& pos, const glm::vec2& size) noexcept = 0; +}; + +} // namespace item +} // namespace client + +#endif diff --git a/src/client/item/items.cc b/src/client/item/items.cc new file mode 100644 index 0000000..9ff25fe --- /dev/null +++ b/src/client/item/items.cc @@ -0,0 +1,16 @@ +#include "client/item/items.hh" + +namespace client { +namespace item { + +shared::item::item_t make_item(const shared::item::item::type_t& type, + const std::uint32_t& quantity) noexcept { + if (type >= shared::item::block::type_offset) { + return std::make_shared<client::item::block>(type, quantity); + } + // TODO non-block items + return std::make_shared<client::item::block>(type, quantity); +} + +} // namespace item +} // namespace client diff --git a/src/client/item/items.hh b/src/client/item/items.hh new file mode 100644 index 0000000..53cebfa --- /dev/null +++ b/src/client/item/items.hh @@ -0,0 +1,17 @@ +#ifndef CLIENT_ITEM_ITEMS_HH_ +#define CLIENT_ITEM_ITEMS_HH_ + +#include "client/item/block.hh" +#include "shared/item/item.hh" +#include "shared/item/items.hh" + +namespace client { +namespace item { + +shared::item::item_t make_item(const shared::item::item::type_t& type, + const std::uint32_t& quantity) noexcept; + +} // namespace item +} // namespace client + +#endif diff --git a/src/client/main.cc b/src/client/main.cc new file mode 100644 index 0000000..858c6df --- /dev/null +++ b/src/client/main.cc @@ -0,0 +1,90 @@ +#include "client/main.hh" + +static bool& get_has_address() noexcept { + static bool ret = false; + return ret; +} + +static bool& get_has_port() noexcept { + static bool ret = false; + return ret; +} + +static std::string& get_address() noexcept { + static std::string address{shared::DEFAULT_ADDRESS}; + return address; +} + +static std::string& get_port() noexcept { + static std::string port{shared::DEFAULT_PORT}; + return port; +} + +static bool& get_is_headless() noexcept { + static bool is_headless = false; + return is_headless; +} + +static bool parse_arg(const int& c, const char* const arg) { + switch (c) { + case 'a': + get_address() = boost::lexical_cast<std::string>(arg); + get_has_address() = true; + break; + case 'p': + get_port() = boost::lexical_cast<std::string>(arg); + get_has_port() = true; + break; + case 'H': + get_is_headless() = true; + break; + case 's': + get_address() = "localhost"; + break; + default: + return false; + } + return true; +} + +static const shared::args_t& get_options() { + static shared::args_t ret = []() -> shared::args_t { + shared::args_t ret{ + {.name = "address", .desc = "connect elsewhere", .val = "a:"}, + {.name = "port", .desc = "override the default port", .val = "p:"}, + {.name = "headless", .desc = "run without a client ", .val = "H"}, + {.name = "singleplayer", + .desc = "avoid hosting a lan server", + .val = "s"}}; + std::ranges::copy(shared::get_options(), std::back_inserter(ret)); + std::ranges::copy(server::get_options(), std::back_inserter(ret)); + return ret; + }(); + + return ret; +} + +int main(const int argc, char* const* argv) { + shared::init(); + + shared::parse_args(argc, argv, get_options(), + {&parse_arg, &shared::parse_arg, &server::parse_arg}); + + if (get_has_address()) { + shared::try_main(client::main, get_address(), get_port()); + return EXIT_SUCCESS; + } + + if (get_is_headless()) { + shared::try_main(server::main, get_address(), get_port()); + return EXIT_SUCCESS; + } + + const std::jthread server_thread{shared::try_main, server::main, + get_address(), get_port()}; + while (!server::has_initialised) { + continue; + } + shared::try_main(client::main, get_address(), get_port()); + return EXIT_SUCCESS; +} diff --git a/src/client/main.hh b/src/client/main.hh new file mode 100644 index 0000000..8610763 --- /dev/null +++ b/src/client/main.hh @@ -0,0 +1,23 @@ +#ifndef CLIENT_MAIN_HH_ +#define CLIENT_MAIN_HH_ + +#include <algorithm> +#include <exception> +#include <execinfo.h> +#include <getopt.h> +#include <iostream> +#include <iterator> +#include <signal.h> +#include <string_view> +#include <thread> +#include <vector> + +#include <boost/lexical_cast.hpp> + +#include "client/client.hh" +#include "server/server.hh" +#include "server/shared.hh" +#include "shared/init.hh" +#include "shared/shared.hh" + +#endif diff --git a/src/client/movement.hh b/src/client/movement.hh deleted file mode 100644 index 82b56b1..0000000 --- a/src/client/movement.hh +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef CLIENT_MOVEMENT_HH_ -#define CLIENT_MOVEMENT_HH_ - -#include "client/world.hh" -#include "shared/movement.hh" -#include "shared/net/net.hh" -#include "shared/player.hh" - -namespace client { -namespace movement { - -void move(shared::player& player, client::world::chunk::map& chunks, - const float deltatime) noexcept; - -enum class interact_mode { add, remove }; -std::optional<std::pair<shared::math::coords, glm::ivec3>> -interact(const shared::player& player, const interact_mode& mode, - const client::world::chunk::map& chunks) noexcept; - -} // namespace movement -} // namespace client - -#endif diff --git a/src/client/movement.cc b/src/client/movement/movement.cc index e5898eb..8712f89 100644 --- a/src/client/movement.cc +++ b/src/client/movement/movement.cc @@ -1,11 +1,11 @@ -#include "client/movement.hh" +#include "client/movement/movement.hh" namespace client { namespace movement { static std::optional<shared::world::block> maybe_get_block(const shared::math::coords& pos, - const client::world::chunk::map& chunks, + const client::world::chunks_t& chunks, const glm::ivec3& block_pos) noexcept { const auto find_it = chunks.find(pos); @@ -20,19 +20,20 @@ maybe_get_block(const shared::math::coords& pos, return find_it->second->get_block(block_pos); } -static std::optional<std::vector<shared::movement::blockinfo>> -make_blockinfos(const shared::player& player, - const client::world::chunk::map& chunks, const int width, - const int height) noexcept { +static std::optional<shared::movement::blocks> +maybe_make_blocks(const glm::vec3& local_pos, + const shared::math::coords& chunk_pos, + const client::world::chunks_t& chunks, const int width, + const int height) noexcept { - std::vector<shared::movement::blockinfo> blockinfos; + shared::movement::blocks blocks; for (int x = -width; x <= width; ++x) { for (int y = -height; y <= height; ++y) { for (int z = -width; z <= width; ++z) { const glm::ivec3 rel_pos = - glm::ivec3{x, y, z} + glm::ivec3{player.local_pos}; + glm::ivec3{x, y, z} + glm::ivec3{local_pos}; if (rel_pos.y < 0 || rel_pos.y >= shared::world::chunk::HEIGHT) { @@ -41,7 +42,7 @@ make_blockinfos(const shared::player& player, const shared::math::coords norm_chunk_pos = shared::world::chunk::get_normalised_chunk( - player.chunk_pos, rel_pos.x, rel_pos.z); + chunk_pos, rel_pos.x, rel_pos.z); const glm::ivec3 norm_pos = shared::world::chunk::get_normalised_coords(rel_pos); @@ -52,72 +53,68 @@ make_blockinfos(const shared::player& player, return std::nullopt; } - const glm::vec3 pos = glm::vec3{rel_pos} - player.local_pos; + const glm::vec3 pos = glm::vec3{rel_pos} - local_pos; const shared::movement::aabb aabb = { .min = glm::vec3{0.0f, 0.0f, 0.0f} + pos, .max = glm::vec3{1.0f, 1.0f, 1.0f} + pos}; - blockinfos.push_back( - shared::movement::blockinfo{.block = block.value(), - .aabb = aabb, - .chunk_pos = norm_chunk_pos, - .pos = norm_pos}); + blocks.push_back( + shared::movement::block{.block = *block, + .aabb = aabb, + .chunk_pos = norm_chunk_pos, + .pos = norm_pos}); } } } - return blockinfos; + return blocks; } -void move(shared::player& player, client::world::chunk::map& chunks, - const float deltatime) noexcept { - const auto blockinfos = - make_blockinfos(player, chunks, shared::movement::move_width, - shared::movement::move_height); - if (!blockinfos.has_value()) { - return; +std::optional<shared::animate> move(const shared::moveable& moveable, + const world::chunks_t& chunks) noexcept { + + const auto xy = shared::movement::get_move_xy(state::tickrate, moveable); + const auto blocks = maybe_make_blocks( + moveable.get_local_pos(), moveable.get_chunk_pos(), chunks, xy.x, xy.y); + if (!blocks.has_value()) { + return std::nullopt; } - shared::movement::move(player, blockinfos.value(), deltatime); + return shared::movement::move(moveable, *blocks, state::tickrate); } std::optional<std::pair<shared::math::coords, glm::ivec3>> -interact(const shared::player& player, const interact_mode& mode, - const client::world::chunk::map& chunks) noexcept { - const auto blockinfos = make_blockinfos(player, chunks, 5, 5); - if (!blockinfos.has_value()) { +interact(const shared::moveable& moveable, const interact_mode& mode, + const client::world::chunks_t& chunks) noexcept { + const auto blocks = maybe_make_blocks( + moveable.get_local_pos(), moveable.get_chunk_pos(), chunks, 5, 5); + if (!blocks.has_value()) { return std::nullopt; } constexpr float epsilon = 0.001f; - constexpr shared::movement::aabb player_aabb = { - .min = {-shared::player::HALFWIDTH + epsilon, 0.0f + epsilon, - -shared::player::HALFWIDTH + epsilon}, - .max = {shared::player::HALFWIDTH - epsilon, - shared::player::HEIGHT - epsilon, - shared::player::HALFWIDTH - epsilon}}; + const auto& aabb = moveable.get_aabb(); constexpr shared::movement::aabb ray_aabb = { .min = {-epsilon, shared::player::EYE_HEIGHT - epsilon, -epsilon}, .max = {epsilon, shared::player::EYE_HEIGHT + epsilon, epsilon}}; const shared::movement::moving_aabb ray_moving_aabb{ - .aabb = ray_aabb, - .velocity = shared::math::angle_to_dir(player.viewangles)}; + .aabb = ray_aabb, .velocity = moveable.get_angles().to_dir()}; - std::optional<std::pair<shared::movement::moving_aabb_ret, - shared::movement::blockinfo>> + std::optional< + std::pair<shared::movement::moving_aabb_ret, shared::movement::block>> best; - for (const auto& blockinfo : *blockinfos) { - if (blockinfo.block == shared::world::block::type::air) { + for (const auto& block : *blocks) { + if (block.block == shared::world::block::type::air) { continue; } - if (!shared::world::block::is_removable(blockinfo.block)) { + if (!shared::world::block::is_removable(block.block)) { continue; } const auto intersect = shared::movement::intersect_moving_aabbs( ray_moving_aabb, - shared::movement::moving_aabb{.aabb = blockinfo.aabb, + shared::movement::moving_aabb{.aabb = block.aabb, .velocity = {0.0f, 0.0f, 0.0f}}); constexpr float MAX_REACH = 3.8f; @@ -128,18 +125,18 @@ interact(const shared::player& player, const interact_mode& mode, continue; } - best = std::make_pair(*intersect, blockinfo); + best = std::make_pair(*intersect, block); } if (!best.has_value()) { return std::nullopt; } - const auto& [intersect, blockinfo] = *best; + const auto& [intersect, block] = *best; - const glm::ivec3 position = blockinfo.pos; + const glm::ivec3 position = block.pos; if (mode == interact_mode::remove) { - return std::make_pair(blockinfo.chunk_pos, position); + return std::make_pair(block.chunk_pos, position); } const glm::ivec3 normal_i = -intersect.normal; @@ -147,15 +144,15 @@ interact(const shared::player& player, const interact_mode& mode, shared::world::chunk::get_normalised_coords(normal_i + position); const auto find_it = - std::find_if(std::begin(*blockinfos), std::end(*blockinfos), + std::find_if(std::begin(*blocks), std::end(*blocks), [&](const auto b) { return b.pos == normalised_pos; }); - if (find_it == std::end(*blockinfos)) { + if (find_it == std::end(*blocks)) { return std::nullopt; } if (!shared::world::block::is_replaceable(find_it->block)) { return std::nullopt; } - if (shared::movement::intersect_aabbs(player_aabb, find_it->aabb)) { + if (shared::movement::intersect_aabbs(aabb, find_it->aabb)) { return std::nullopt; } return std::make_pair(find_it->chunk_pos, normalised_pos); diff --git a/src/client/movement/movement.hh b/src/client/movement/movement.hh new file mode 100644 index 0000000..19144ba --- /dev/null +++ b/src/client/movement/movement.hh @@ -0,0 +1,27 @@ +#ifndef CLIENT_MOVEMENT_MOVEMENT_HH_ +#define CLIENT_MOVEMENT_MOVEMENT_HH_ + +#include <cstdint> +#include <optional> + +#include "client/state/state.hh" +#include "client/world/chunk.hh" +#include "shared/entity/moveable.hh" +#include "shared/movement/movement.hh" +#include "shared/net/net.hh" + +namespace client { +namespace movement { + +std::optional<shared::animate> move(const shared::moveable& moveable, + const world::chunks_t& chunks) noexcept; + +enum class interact_mode { add, remove }; +std::optional<std::pair<shared::math::coords, glm::ivec3>> +interact(const shared::moveable& player, const interact_mode& mode, + const world::chunks_t& chunks) noexcept; + +} // namespace movement +} // namespace client + +#endif diff --git a/src/client/player.cc b/src/client/player.cc deleted file mode 100644 index 5ff4118..0000000 --- a/src/client/player.cc +++ /dev/null @@ -1,58 +0,0 @@ -#include "player.hh" - -glm::vec3 client::player::get_world_pos(const shared::player& lp) noexcept { - // clang-format off - const float world_x = static_cast<float>(this->chunk_pos.x - lp.chunk_pos.x) * shared::world::chunk::WIDTH + this->local_pos.x; - const float world_y = static_cast<float>(this->local_pos.y) + shared::player::HEIGHT / 2.0f; - const float world_z = static_cast<float>(this->chunk_pos.z - lp.chunk_pos.z) * shared::world::chunk::WIDTH + this->local_pos.z; - // clang-format on - return {world_x, world_y, world_z}; -} - -void client::player::draw_playermodel( - const shared::player& localplayer) noexcept { - - static client::render::model playermodel{"res/models/player/player.obj"}; - static client::render::program program{"res/shaders/model.vs", - "res/shaders/model.fs"}; - - const glm::vec3 world_pos = this->get_world_pos(localplayer); - const glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), -this->viewangles.yaw, - glm::vec3(0.0f, 1.0f, 0.0f)); - const glm::mat4 translate = glm::translate(glm::mat4(1.0f), world_pos); - const glm::mat4& view = client::render::camera::get_view(); - const glm::mat4& proj = client::render::camera::get_proj(); - - playermodel.draw(program, proj * view * translate * rotate); -} - -void client::player::draw_message(const shared::player& localplayer) noexcept { - // Clear the message if it's too old. - if (this->message.has_value()) { - const auto now = std::chrono::steady_clock::now(); - if (now > this->message->receive_time + player::MSG_SHOW_TIME) { - this->message.reset(); - } - } - - if (!this->message.has_value()) { - return; - } - - const glm::vec3 world_pos = this->get_world_pos(localplayer); - const auto pos = client::math::world_to_screen(world_pos); - - if (!pos.has_value()) { - return; - } - - const glm::vec2& window = client::render::get_window_size(); - const glm::mat4 proj = glm::ortho(0.0f, window.x, 0.0f, window.y); - const glm::mat4 tran = - glm::translate(glm::mat4(1.0f), - glm::vec3{std::floor(pos->x), std::floor(pos->y), 0.0f}); - - constexpr glm::vec4 white{1.0f, 1.0f, 1.0f, 1.0f}; - client::render::render_text(this->message->text, 30.0f, true, true, white, - proj * tran); -} diff --git a/src/client/player.hh b/src/client/player.hh deleted file mode 100644 index c41ba23..0000000 --- a/src/client/player.hh +++ /dev/null @@ -1,64 +0,0 @@ -#ifndef CLIENT_PLAYER_HH_ -#define CLIENT_PLAYER_HH_ - -#include <chrono> -#include <optional> -#include <string> -#include <utility> - -#include "client/math.hh" -#include "client/render/camera.hh" -#include "client/render/model.hh" -#include "client/render/program.hh" -#include "shared/player.hh" - -namespace client { - -// Renderable player, similar to client::chunk. We also store the message the -// player wants to say. -class player : public shared::player { -public: - static constexpr auto MSG_SHOW_TIME = std::chrono::seconds(15); - struct message { - std::string text; - std::chrono::time_point<std::chrono::steady_clock> receive_time; - message(const std::string& message) noexcept { - this->text = message; - this->receive_time = std::chrono::steady_clock::now(); - } - }; - std::optional<message> message; - -private: - glm::vec3 get_world_pos(const shared::player& lp) noexcept; - -public: - player(shared::player&& p) noexcept - : shared::player(std::forward<shared::player>(p)) {} - player(const shared::player& p) noexcept : shared::player(p) {} - - void update(const shared::player& p) noexcept { - this->index = p.index; // there is no syntax for doing this in one line - this->commands = p.commands; - this->chunk_pos = p.chunk_pos; - this->local_pos = p.local_pos; - this->viewangles = p.viewangles; - this->velocity = p.velocity; - } - - void draw_playermodel(const shared::player& localplayer) noexcept; - void draw_message(const shared::player& localplayer) noexcept; - - const std::optional<struct message>& get_message() const noexcept { - return this->message; - } -}; - -using players = std::vector<player>; -static inline client::player& get_localplayer(players& players) noexcept { - return players[0]; -} - -} // namespace client - -#endif diff --git a/src/client/draw.cc b/src/client/render/draw.cc index c549ffe..d9ea9c3 100644 --- a/src/client/draw.cc +++ b/src/client/render/draw.cc @@ -1,53 +1,7 @@ -#include "draw.hh" +#include "client/render/draw.hh" namespace client { -namespace draw { - -void draw_rectangle(const rectangle_args& ra) noexcept { - const glm::vec2 pos = ra.pos.to_vec2(); - const glm::vec2 size = ra.size.to_vec2(); - - // We want to render from the bottom left corner. - render::render_rectangle(pos + (size / 2.0f), size, ra.colour); -} - -void draw_colour(const glm::vec4& colour) noexcept { - const rectangle_args args = { - .pos = {.extent = {0.0f, 0.0f}}, - .size = {.extent = {1.0f, 1.0f}}, - .colour = colour, - }; - draw_rectangle(args); -} - -void draw_text(const std::string_view text, const text_args& args) noexcept { - const glm::vec2& window = render::get_window_size(); - const float x = floorf(window.x * args.pos.extent.x + args.pos.offset.x); - const float y = floorf(window.y * args.pos.extent.y + args.pos.offset.y); - const unsigned height = static_cast<unsigned>( - args.extent_height * window.y + args.offset_height); - - const auto make_matrix = [&](const float xo, const float yo) -> glm::mat4 { - constexpr auto identity = glm::mat4(1.0f); - const auto proj = glm::ortho(0.f, window.x, 0.f, window.y); - const auto tran = - glm::translate(identity, glm::vec3{x + xo, y + yo, 0.0f}); - return proj * tran; - }; - - glDisable(GL_DEPTH_TEST); - glDisable(GL_BLEND); - if (args.has_backing) { - constexpr glm::vec4 black{0.0f, 0.0f, 0.0f, 1.0f}; - render::render_text(text, height, args.is_centered, args.is_vcentered, - black, make_matrix(1.0f, -2.0f)); - } - glEnable(GL_BLEND); - - render::render_text(text, height, args.is_centered, args.is_vcentered, - args.colour, make_matrix(0, 0)); - glEnable(GL_DEPTH_TEST); -} +namespace render { static void draw_state_info(const shared::player& lp) noexcept { @@ -58,14 +12,16 @@ static void draw_state_info(const shared::player& lp) noexcept { }; const auto make_position = [&]() -> std::string { - const auto chunk_x = lp.chunk_pos.x; - const auto chunk_z = lp.chunk_pos.z; - const auto x = static_cast<double>(lp.local_pos.x); - const auto y = static_cast<double>(lp.local_pos.y); - const auto z = static_cast<double>(lp.local_pos.z); + const auto chunk_x = lp.get_chunk_pos().x; + const auto chunk_z = lp.get_chunk_pos().z; + const auto x = static_cast<double>(lp.get_local_pos().x); + const auto y = static_cast<double>(lp.get_local_pos().y); + const auto z = static_cast<double>(lp.get_local_pos().z); constexpr auto WIDTH = shared::world::chunk::WIDTH; - const auto abs_x = static_cast<double>(lp.chunk_pos.x) * WIDTH + x; - const auto abs_z = static_cast<double>(lp.chunk_pos.z) * WIDTH + z; + const auto abs_x = + static_cast<double>(lp.get_chunk_pos().x) * WIDTH + x; + const auto abs_z = + static_cast<double>(lp.get_chunk_pos().z) * WIDTH + z; constexpr auto nstr = [](const double d) -> std::string { auto str = std::to_string(d); @@ -80,16 +36,16 @@ static void draw_state_info(const shared::player& lp) noexcept { }; const auto make_direction = [&]() -> std::string { - const float yaw = glm::degrees(lp.viewangles.yaw); - const float pitch = glm::degrees(lp.viewangles.pitch); + const float yaw = glm::degrees(lp.get_angles().yaw); + const float pitch = glm::degrees(lp.get_angles().pitch); const std::string bearing = [&]() -> std::string { - if (yaw >= 315.0f || yaw < 45.0f) { - return "North"; - } else if (yaw >= 45.0f && yaw < 135.0f) { - return "East"; - } else if (yaw >= 135.0f && yaw < 225.0f) { + if (yaw > 135.0f || yaw < -135.0f) { return "South"; + } else if (yaw > 45.0f) { + return "East"; + } else if (yaw > -45.0f) { + return "North"; } else { return "West"; } @@ -100,34 +56,65 @@ static void draw_state_info(const shared::player& lp) noexcept { }; const auto make_address = []() -> std::string { - const std::string address = std::string(client::state.address); - const std::string port = std::string(client::state.port); + const std::string address = std::string(client::state::address); + const std::string port = std::string(client::state::port); return "address: " + address + ":" + port; }; + const auto make_tickrate = [&]() -> std::string { + return "tickrate: " + std::to_string(state::tickrate); + }; + const auto make_seed = []() -> std::string { - return "seed: " + std::to_string(client::state.seed); + return "seed: " + std::to_string(client::state::seed); }; - const auto make_players = []() -> std::string { - const auto index = std::to_string(client::state.localplayer); + const auto make_entities = []() -> std::string { + const auto index = std::to_string(*client::state::localplayer_index); return "index: " + index; }; const auto make_chunks = []() -> std::string { - return "chunks [req, rcv]: " + - std::to_string(client::state.requested_chunk_count) + ", " + - std::to_string(client::state.networked_chunk_count) + " @ " + - std::to_string(client::state.draw_distance) + " draw distance"; + return "chunks: " + + std::to_string(client::state::requested_chunk_count) + ", " + + std::to_string(client::state::networked_chunk_count) + " @ " + + std::to_string(client::state::draw_distance) + " draw distance"; }; const auto make_speed = [&]() -> std::string { - return "speed: " + nstr(glm::length(lp.velocity)) + " b/s"; + return "speed: " + nstr(glm::length(lp.get_velocity())) + " b/s"; }; const auto make_velocity = [&]() -> std::string { - return "velocity: (" + nstr(lp.velocity.x) + ", " + - nstr(lp.velocity.y) + ", " + nstr(lp.velocity.z) + ")"; + return "velocity: (" + nstr(lp.get_velocity().x) + ", " + + nstr(lp.get_velocity().y) + ", " + nstr(lp.get_velocity().z) + + ")"; + }; + + const auto make_msg = [&]() -> std::string { + const auto& message = get_localplayer().get_message(); + return "message: " + (message.has_value() ? message->text : ""); + }; + + const auto make_biome = [&]() -> std::string { + const int x = static_cast<int>(lp.get_local_pos().x); + const int z = static_cast<int>(lp.get_local_pos().z); + const auto is_inside = [](const int val) { + return std::clamp(val, 0, shared::world::chunk::WIDTH) == val; + }; + if (!is_inside(x) || !is_inside(z)) { + return "?"; + } + + const auto find_it = client::state::chunks.find(lp.get_chunk_pos()); + if (find_it == std::end(client::state::chunks)) { + return "?"; + } + const auto& chunk = find_it->second; + if (!chunk.has_value()) { + return "?"; + } + return std::string{"biome: "} + chunk->get_biome(x, z); }; // Draws all of our strings and works its way down the top of the screen. @@ -139,15 +126,18 @@ static void draw_state_info(const shared::player& lp) noexcept { draw_text(str, args); args.pos.extent.y -= 0.02f; }; - draw_str_trail("blockgame_linux v0.20"); + draw_str_trail("blockgame_linux v0.22"); draw_str_trail(make_address()); + draw_str_trail(make_tickrate()); draw_str_trail(make_seed()); - draw_str_trail(make_players()); + draw_str_trail(make_entities()); draw_str_trail(make_chunks()); draw_str_trail(make_position()); draw_str_trail(make_direction()); draw_str_trail(make_speed()); draw_str_trail(make_velocity()); + draw_str_trail(make_biome()); + draw_str_trail(make_msg()); } static void draw_fps() noexcept { @@ -180,26 +170,38 @@ static void draw_overlay(const shared::player& lp) noexcept { draw_fps(); } -static void draw_main_pass(const shared::player& localplayer, - client::players& players, - client::world::chunk::map& chunks) noexcept { - for (auto& chunk : chunks) { - if (!chunk.second.has_value()) { - continue; +static void draw_main_pass(const client::player& localplayer, + client::entities_t& entities, + client::world::chunks_t& chunks) noexcept { + + { + // zero means no limit + const unsigned chunks_per_frame = + client::settings::get<unsigned>({"video", "chunks_per_frame"}, 0u); + unsigned chunks_regenerated = 0u; + for (auto& chunk : chunks) { + if (!chunk.second.has_value()) { + continue; + } + + const bool skip = chunks_per_frame == 0 + ? false + : chunks_regenerated >= chunks_per_frame; + chunks_regenerated += chunk.second->draw( + chunks, localplayer, world::chunk::pass::solid, skip); } - chunk.second->draw(chunks, localplayer, - client::world::chunk::pass::solid); } - // Draw players while ignoring the localplayer, which is always 0'th! - // This also handles drawing messages. - for (auto i = 1u; i < std::size(players); ++i) { - players[i].draw_playermodel(localplayer); + for (const auto& [index, entity_ptr] : entities) { + if (index == localplayer.get_index()) { + continue; + } + entity_ptr->draw(localplayer); } } -static void draw_water_pass(const shared::player& localplayer, - client::world::chunk::map& chunks) noexcept { +static void draw_water_pass(const client::player& localplayer, + client::world::chunks_t& chunks) noexcept { for (auto& chunk : chunks) { if (!chunk.second.has_value()) { continue; @@ -209,37 +211,33 @@ static void draw_water_pass(const shared::player& localplayer, } } -static void draw_wts_text(const shared::player& localplayer, - client::players& players) noexcept { - for (auto i = 1u; i < std::size(players); ++i) { - players[i].draw_message(localplayer); +static void draw_wts_text(const client::player& localplayer, + client::entities_t& entities) noexcept { + for (const auto& [index, entity_ptr] : entities) { + if (index == localplayer.get_index()) { + continue; + } + entity_ptr->draw_wts(localplayer); } } static void draw_hud(const client::player& localplayer, - const client::world::chunk::map& chunks) noexcept { - if (client::input::is_key_toggled(SDLK_F3)) { + const client::world::chunks_t& chunks) noexcept { + const auto should_draw_hud = !client::input::is_key_toggled(SDLK_F1); + if (client::input::is_key_toggled(SDLK_F3) && should_draw_hud) { draw_overlay(localplayer); } - if (const auto& msg = localplayer.get_message(); msg.has_value()) { - if (msg->receive_time + player::MSG_SHOW_TIME >= - std::chrono::steady_clock::now()) { - draw_text(msg->text, {.pos = relative_arg{.extent = {0.5f, 0.0f}, - .offset = {0.0f, 2.0f}}, - .extent_height = 0.0165f, - .colour = {1.0f, 1.0f, 1.0f, 1.0f}, - .has_backing = true, - .is_centered = true}); - } + if (client::window::is_open()) { + return; } - if (client::window::is_open()) { + if (!should_draw_hud) { return; } // crosshair - client::draw::draw_rectangle( + client::render::draw_rectangle( {.pos = {.extent = {0.5f, 0.5f}, .offset = {-3.0f, -3.0f}}, .size = {.offset = {6.0f, 6.0f}}, .colour = {1.0f, 1.0f, 1.0f, 1.0f}}); @@ -250,10 +248,10 @@ static void draw_hud(const client::player& localplayer, interact.has_value()) { const auto [world_x, world_z] = [&]() -> std::pair<float, float> { - const float offset_x = - static_cast<float>(interact->first.x - localplayer.chunk_pos.x); - const float offset_z = - static_cast<float>(interact->first.z - localplayer.chunk_pos.z); + const float offset_x = static_cast<float>( + interact->first.x - localplayer.get_chunk_pos().x); + const float offset_z = static_cast<float>( + interact->first.z - localplayer.get_chunk_pos().z); return {offset_x * shared::world::chunk::WIDTH, offset_z * shared::world::chunk::WIDTH}; }(); @@ -275,20 +273,19 @@ static void update_camera(const shared::player& localplayer) noexcept { // bit of maths for calculating the max distance we could can see client::render::camera::get_zfar() = std::hypot( static_cast<float>(world::chunk::HEIGHT), - float(client::state.draw_distance) * std::hypot(16.0f, 16.0f)); + float(client::state::draw_distance) * std::hypot(16.0f, 16.0f)); client::render::camera::get_pos() = - localplayer.local_pos + + localplayer.get_local_pos() + glm::vec3{0.0f, shared::player::EYE_HEIGHT, 0.0f}; - client::render::camera::get_front() = - shared::math::angle_to_dir(localplayer.viewangles); + client::render::camera::get_front() = localplayer.get_angles().to_dir(); client::render::camera::update(); } // We create framebuffer here to enable postprocessing and solve some // rendering problems. -static void draw_buffers(const shared::player& localplayer, - client::players& players, - client::world::chunk::map& chunks) noexcept { +static void draw_buffers(const client::player& localplayer, + client::entities_t& entities, + client::world::chunks_t& chunks) noexcept { const auto make_vbo = [](const auto& vertices) -> GLuint { GLuint vbo = 0; glGenBuffers(1, &vbo); @@ -367,7 +364,7 @@ static void draw_buffers(const shared::player& localplayer, // We render our main scene on the main framebuffer. glBindFramebuffer(GL_FRAMEBUFFER, fbo_main); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - draw_main_pass(localplayer, players, chunks); + draw_main_pass(localplayer, entities, chunks); // We render our water scene on the water framebuffer. glBindFramebuffer(GL_FRAMEBUFFER, fbo_water); @@ -375,7 +372,7 @@ static void draw_buffers(const shared::player& localplayer, const bool is_underwater = [&]() -> bool { const glm::ivec3 pos{client::render::camera::get_pos()}; - const auto find_it = chunks.find(localplayer.chunk_pos); + const auto find_it = chunks.find(localplayer.get_chunk_pos()); if (find_it == std::end(chunks) || !find_it->second.has_value()) { return false; } @@ -412,21 +409,20 @@ static void draw_buffers(const shared::player& localplayer, glEnable(GL_DEPTH_TEST); } -void draw(client::players& players, - client::world::chunk::map& chunks) noexcept { - const auto& localplayer = client::get_localplayer(players); +void draw(entities_t& entities, world::chunks_t& chunks) noexcept { + const auto& localplayer = get_localplayer(); update_camera(localplayer); client::render::update_uniforms(); - draw_buffers(localplayer, players, chunks); + draw_buffers(localplayer, entities, chunks); draw_hud(localplayer, chunks); - draw_wts_text(localplayer, players); + draw_wts_text(localplayer, entities); client::window::draw(); client::render::swap_window(); } -} // namespace draw +} // namespace render } // namespace client diff --git a/src/client/render/draw.hh b/src/client/render/draw.hh new file mode 100644 index 0000000..bf43224 --- /dev/null +++ b/src/client/render/draw.hh @@ -0,0 +1,30 @@ +#ifndef CLIENT_RENDER_DRAW_HH_ +#define CLIENT_RENDER_DRAW_HH_ + +#include <string_view> + +#include <glm/glm.hpp> + +#include "client/entity/player.hh" +#include "client/input.hh" +#include "client/movement/movement.hh" +#include "client/render/camera.hh" +#include "client/render/program.hh" +#include "client/render/render.hh" +#include "client/render/struct.hh" +#include "client/settings.hh" +#include "client/shared.hh" +#include "client/window/hud_window.hh" +#include "client/window/window.hh" +#include "client/world/chunk.hh" + +namespace client { +namespace render { + +void draw(client::entities_t& players, + client::world::chunks_t& chunks) noexcept; + +} // namespace render +} // namespace client + +#endif diff --git a/src/client/render/render.cc b/src/client/render/render.cc index 18aa32a..941988d 100644 --- a/src/client/render/render.cc +++ b/src/client/render/render.cc @@ -27,7 +27,7 @@ SDL_Window* const& get_sdl_window() noexcept { std::bind(SDL_GL_SetAttribute, SDL_GL_CONTEXT_MINOR_VERSION, 2)); SDL_Window* const ret = - SDL_CreateWindow("blockgame_linux", 0, 0, 0, 0, + SDL_CreateWindow("blockgame_linux", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 0, 0, SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_BORDERLESS); check_sdl_pointer(ret); @@ -124,6 +124,71 @@ void swap_window() noexcept { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } +// Additional sanity checks for our atlas. +static void check_atlas(const client::render::texture& texture) { + if (texture.width % 6) { + throw std::runtime_error("invalid atlas; WIDTH is not divisible by 6"); + } + if (texture.height % (texture.width / 6)) { + throw std::runtime_error( + "invalid atlas, HEIGHT is not divisible by (WIDTH / 6)"); + } +} + +GLuint get_texture_atlas() noexcept { + static const auto atlas = []() -> GLuint { + GLuint texture = 0; + glActiveTexture(GL_TEXTURE1); + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D_ARRAY, texture); + + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, + GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, + GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, + GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_ANISOTROPY, 16.0f); + + const client::render::texture stbi{"res/textures/atlas.png"}; + check_atlas(stbi); + const int face_size = stbi.width / 6; + + // 2D texture array, where our depth is our block face. + glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, face_size, face_size, + 6 * (stbi.height / face_size), 0, + stbi.channels == 3 ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, + nullptr); + + // Fill the 2D texture array. + // Because our image has multiple images on the x-axis and opengl + // expects a single image per axis, we must fill it in row by row. + const auto get_pixel_xy = [&stbi](const int x, const int y) { + return stbi.image + 4 * (y * stbi.width + x); + }; + for (int x = 0; x < 6; ++x) { + const int x_pixel = x * face_size; + + for (int y = 0; y < stbi.height / face_size; ++y) { + const int y_pixel = y * face_size; + + for (auto row = 0; row < face_size; ++row) { + glTexSubImage3D( + GL_TEXTURE_2D_ARRAY, 0, 0, row, x + y * 6, face_size, 1, + 1, GL_RGBA, GL_UNSIGNED_BYTE, + get_pixel_xy(x_pixel, row + y_pixel)); // pixel + } + } + } + + glGenerateMipmap(GL_TEXTURE_2D_ARRAY); + + return texture; + }(); + return atlas; +} + void render_cube_outline(const glm::vec3& pos, const glm::vec4& colour) noexcept { const auto generate_vbo = [](const auto& vertices) -> GLuint { @@ -427,6 +492,8 @@ public: font_atlas(const unsigned size) noexcept : font_size(size), texture(make_texture_info(size)) {} ~font_atlas() noexcept { glDeleteTextures(1, &this->texture.texture); } + font_atlas(font_atlas&&) = delete; + font_atlas(const font_atlas&) = delete; GLint get_height() const noexcept { return this->texture.height; } GLint get_width() const noexcept { return this->texture.width; } @@ -578,25 +645,71 @@ void update_uniforms() noexcept { }; static const GLuint ubo = make_ubo(); - ubo_data upload = {.proj = camera::get_proj(), - .view = camera::get_view(), - .frustum = camera::get_frustum(), - .znear = camera::get_znear(), - .zfar = camera::get_zfar(), - .xfov = glm::radians(camera::get_xfov()), - .yfov = glm::radians(camera::get_yfov()), - .time = []() -> unsigned { - static const auto start = - std::chrono::steady_clock::now(); - const auto now = std::chrono::steady_clock::now(); - return static_cast<unsigned>( - (now - start) / std::chrono::milliseconds(1)); - }(), - .xwindow = static_cast<float>(get_window_size().x), - .ywindow = static_cast<float>(get_window_size().y)}; + const ubo_data upload = { + .proj = camera::get_proj(), + .view = camera::get_view(), + .frustum = camera::get_frustum(), + .znear = camera::get_znear(), + .zfar = camera::get_zfar(), + .xfov = glm::radians(camera::get_xfov()), + .yfov = glm::radians(camera::get_yfov()), + .time = []() -> unsigned { + static const auto start = std::chrono::steady_clock::now(); + const auto now = std::chrono::steady_clock::now(); + return static_cast<unsigned>((now - start) / + std::chrono::milliseconds(1)); + }(), + .xwindow = static_cast<float>(get_window_size().x), + .ywindow = static_cast<float>(get_window_size().y)}; glBindBuffer(GL_UNIFORM_BUFFER, ubo); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(upload), &upload); } +void draw_rectangle(const rectangle_args& ra) noexcept { + const glm::vec2 pos = ra.pos.to_vec2(); + const glm::vec2 size = ra.size.to_vec2(); + + // We want to render from the bottom left corner. + render::render_rectangle(pos + (size / 2.0f), size, ra.colour); +} + +void draw_colour(const glm::vec4& colour) noexcept { + const rectangle_args args = { + .pos = {.extent = {0.0f, 0.0f}}, + .size = {.extent = {1.0f, 1.0f}}, + .colour = colour, + }; + draw_rectangle(args); +} + +void draw_text(const std::string_view text, const text_args& args) noexcept { + const glm::vec2& window = render::get_window_size(); + const float x = floorf(window.x * args.pos.extent.x + args.pos.offset.x); + const float y = floorf(window.y * args.pos.extent.y + args.pos.offset.y); + const unsigned height = static_cast<unsigned>( + args.extent_height * window.y + args.offset_height); + + const auto make_matrix = [&](const float xo, const float yo) -> glm::mat4 { + constexpr auto identity = glm::mat4(1.0f); + const auto proj = glm::ortho(0.f, window.x, 0.f, window.y); + const auto tran = + glm::translate(identity, glm::vec3{x + xo, y + yo, 0.0f}); + return proj * tran; + }; + + glDisable(GL_DEPTH_TEST); + glDisable(GL_BLEND); + if (args.has_backing) { + constexpr glm::vec4 black{0.0f, 0.0f, 0.0f, 1.0f}; + render_text(text, height, args.is_centered, args.is_vcentered, black, + make_matrix(2.0f, -2.0f)); + } + glEnable(GL_BLEND); + + render_text(text, height, args.is_centered, args.is_vcentered, args.colour, + make_matrix(0, 0)); + glEnable(GL_DEPTH_TEST); +} + } // namespace render } // namespace client diff --git a/src/client/render/render.hh b/src/client/render/render.hh index ca98e6f..c98043a 100644 --- a/src/client/render/render.hh +++ b/src/client/render/render.hh @@ -27,8 +27,10 @@ #include "client/render/camera.hh" #include "client/render/program.hh" +#include "client/render/struct.hh" +#include "client/render/texture.hh" #include "shared/shared.hh" -#include "shared/world.hh" +#include "shared/world/chunk.hh" namespace client { namespace render { @@ -40,6 +42,7 @@ void quit() noexcept; int get_fps() noexcept; SDL_Window* const& get_sdl_window() noexcept; const glm::ivec2& get_window_size() noexcept; +GLuint get_texture_atlas() noexcept; // Update void update_uniforms() noexcept; @@ -54,7 +57,26 @@ void render_text(const std::string_view text, const unsigned int size, void render_cube_outline(const glm::vec3& pos, const glm::vec4& colour) noexcept; +// Draw is similar to render but more abstracted. +void draw_colour(const glm::vec4& colour) noexcept; +struct rectangle_args { + relative_arg pos; + relative_arg size; + glm::vec4 colour; +}; +void draw_rectangle(const rectangle_args& args) noexcept; + +struct text_args { + relative_arg pos; + float extent_height; // we don't get width here, + float offset_height; + glm::vec4 colour; + bool has_backing; + bool is_centered; + bool is_vcentered; +}; +void draw_text(const std::string_view text, const text_args& args) noexcept; } // namespace render } // namespace client diff --git a/src/client/render/struct.cc b/src/client/render/struct.cc new file mode 100644 index 0000000..a7a1b5d --- /dev/null +++ b/src/client/render/struct.cc @@ -0,0 +1 @@ +#include "client/render/struct.hh" diff --git a/src/client/render/struct.hh b/src/client/render/struct.hh new file mode 100644 index 0000000..fd00ffd --- /dev/null +++ b/src/client/render/struct.hh @@ -0,0 +1,29 @@ +#ifndef CLIENT_RENDER_STRUCT_HH_ +#define CLIENT_RENDER_STRUCT_HH_ + +//#include <client/render/render.hh> +#include <glm/glm.hpp> + +namespace client { +namespace render { + +const glm::ivec2& get_window_size() noexcept; // forward declaration + +// Scale takes the range [0, 1] and represents an amount of the screen. +// Offset is any value that is added after scale. +struct relative_arg { + glm::vec2 extent; + glm::vec2 offset; + + glm::vec2 to_vec2() const noexcept { + const glm::vec2& window = render::get_window_size(); + const float x = this->extent.x * window.x + this->offset.x; + const float y = this->extent.y * window.y + this->offset.y; + return {x, y}; + } +}; + +} // namespace render +} // namespace client + +#endif diff --git a/src/client/settings.cc b/src/client/settings.cc index 8e2d0c9..3253f60 100644 --- a/src/client/settings.cc +++ b/src/client/settings.cc @@ -9,7 +9,7 @@ const char* const config_name = "blockgame_linux.conf"; namespace client { namespace settings { -static std::string get_settings_file() noexcept { +static std::string get_settings_file() { std::filesystem::create_directories(home_dir + ::config_dir); std::ifstream in{home_dir + ::config_dir + config_name, std::fstream::in | std::fstream::app}; @@ -20,7 +20,7 @@ static std::string get_settings_file() noexcept { return file.ends_with('\n') ? file : file + '\n'; } -static void set_settings_file(const std::string_view contents) noexcept { +static void set_settings_file(const std::string_view contents) { std::filesystem::create_directories(home_dir + ::config_dir); std::ofstream out{home_dir + ::config_dir + ::config_name, std::fstream::out | std::fstream::trunc}; @@ -31,7 +31,7 @@ static void set_settings_file(const std::string_view contents) noexcept { // Heading maps setting to headings (ie, "camera -> {map with fov, 100.0f}). using value_map = std::unordered_map<std::string, std::string>; using setting_map = std::unordered_map<std::string, value_map>; -static setting_map& get_settings() noexcept { +static setting_map& get_settings() { static setting_map ret = []() -> setting_map { setting_map settings{}; @@ -50,8 +50,9 @@ static setting_map& get_settings() noexcept { const size_t split_pos = line.find_first_of(':'); if (split_pos == std::string::npos) { - shared::print::warn("client: failed to parse line in settings " - "file, consider manual intervention\n"); + shared::print::warn + << "client: failed to parse line in settings file, " + "consider manual intervention\n"; continue; } @@ -72,10 +73,21 @@ static setting_map& get_settings() noexcept { return ret; } -// TODO fix this bit of code duplication -std::string -get_setting_str(const std::pair<const std::string&, const std::string&> loc, - const std::string default_value) noexcept { +std::optional<std::string> maybe_get_setting_str(const setting_pair_t& loc) { + const auto& [heading, name] = loc; + + setting_map& settings = get_settings(); + value_map& values = settings[heading]; + + const auto it = values.find(name); + if (it == std::end(values)) { + return std::nullopt; + } + return it->second; +} + +std::string get_setting_str(const setting_pair_t& loc, + const std::string default_value) { const auto& [heading, name] = loc; setting_map& settings = get_settings(); @@ -89,9 +101,7 @@ get_setting_str(const std::pair<const std::string&, const std::string&> loc, return find_it->second; } -void set_setting_str( - const std::pair<const std::string&, const std::string&> loc, - const std::string& value) noexcept { +void set_setting_str(const setting_pair_t& loc, const std::string& value) { const auto& [heading, name] = loc; setting_map& settings = get_settings(); @@ -105,7 +115,7 @@ void set_setting_str( find_it->second = value; } -void save() noexcept { +void save() { std::string contents; const setting_map& settings = get_settings(); diff --git a/src/client/settings.hh b/src/client/settings.hh index d65022b..11b785c 100644 --- a/src/client/settings.hh +++ b/src/client/settings.hh @@ -9,7 +9,7 @@ #include <boost/lexical_cast.hpp> -#include "client/shared.hh" +//#include "client/shared.hh" #include "shared/shared.hh" // This settings file just provides functionality for persistent variables, @@ -18,20 +18,20 @@ namespace client { namespace settings { -void set_setting_str( - const std::pair<const std::string&, const std::string&> loc, - const std::string& value) noexcept; +using setting_pair_t = std::pair<std::string, std::string>; -std::string -get_setting_str(const std::pair<const std::string&, const std::string&> loc, - const std::string default_value) noexcept; +std::optional<std::string> maybe_get_setting_str(const setting_pair_t&); + +void set_setting_str(const setting_pair_t& loc, const std::string& value); + +std::string get_setting_str(const setting_pair_t& loc, + const std::string default_value); // Attempts to read the setting in the file, returning it if it exists. // If either name or category does not exist, writes the default value in // the file under the expected headings. template <typename T> -T get(const std::pair<const std::string, const std::string>& loc, - const T& default_value) noexcept { +T get(const setting_pair_t& loc, const T& default_value) { const std::string value = get_setting_str(loc, boost::lexical_cast<std::string>(default_value)); return boost::lexical_cast<T>(value); @@ -40,12 +40,11 @@ T get(const std::pair<const std::string, const std::string>& loc, // Attempts to set the setting in the file, overwriting the pre-existing // value or writing a new entry. template <typename T> -void set(const std::pair<const std::string, const std::string>& loc, - const T& value) noexcept { +void set(const setting_pair_t& loc, const T& value) { set_setting_str(loc, boost::lexical_cast<std::string>(value)); } -void save() noexcept; +void save(); } // namespace settings } // namespace client diff --git a/src/client/shared.cc b/src/client/shared.cc index 3c6a2ec..0346e3d 100644 --- a/src/client/shared.cc +++ b/src/client/shared.cc @@ -1 +1,18 @@ #include "shared.hh" + +namespace client { + +entities_t::iterator get_entity_it(const std::uint32_t& index) noexcept { + return client::state::entities.find(index); +} + +shared::entity& get_entity(const std::uint32_t index) noexcept { + return *get_entity_it(index)->second; +} + +client::player& get_localplayer() noexcept { + return dynamic_cast<client::player&>( + get_entity(*client::state::localplayer_index)); +} + +} // namespace client diff --git a/src/client/shared.hh b/src/client/shared.hh index 557d13a..31c0ded 100644 --- a/src/client/shared.hh +++ b/src/client/shared.hh @@ -1,28 +1,14 @@ #ifndef CLIENT_SHARED_HH_ #define CLIENT_SHARED_HH_ -#include <cstdint> -#include <string_view> - -#include "shared/net/connection.hh" +#include "client/entity/player.hh" +#include "client/state/entities.hh" namespace client { -struct state { - std::string_view address; - std::string_view port; - std::uint64_t seed; - std::uint32_t localplayer; - std::size_t player_count; - std::size_t requested_chunk_count; - std::size_t networked_chunk_count; - std::int32_t draw_distance; - std::uint16_t latency; - - shared::net::connection* connection = nullptr; -}; - -inline state state; +entities_t::iterator get_entity_it(const std::uint32_t& index) noexcept; +shared::entity& get_entity(const std::uint32_t index) noexcept; +client::player& get_localplayer() noexcept; }; // namespace client diff --git a/src/client/state/chunks.cc b/src/client/state/chunks.cc new file mode 100644 index 0000000..470c552 --- /dev/null +++ b/src/client/state/chunks.cc @@ -0,0 +1 @@ +#include "client/state/chunks.hh" diff --git a/src/client/state/chunks.hh b/src/client/state/chunks.hh new file mode 100644 index 0000000..e0d4d82 --- /dev/null +++ b/src/client/state/chunks.hh @@ -0,0 +1,18 @@ +#ifndef CLIENT_STATE_CHUNKS_HH_ +#define CLIENT_STATE_CHUNKS_HH_ + +#include <memory> +#include <unordered_map> + +#include "client/world/chunk.hh" + +namespace client { +namespace state { + +inline client::world::chunks_t chunks{4096, shared::world::chunk::hash, + shared::world::chunk::equal}; + +} // namespace state +} // namespace client + +#endif diff --git a/src/client/state/entities.cc b/src/client/state/entities.cc new file mode 100644 index 0000000..efb3533 --- /dev/null +++ b/src/client/state/entities.cc @@ -0,0 +1 @@ +#include "client/state/entities.hh" diff --git a/src/client/state/entities.hh b/src/client/state/entities.hh new file mode 100644 index 0000000..3c807b9 --- /dev/null +++ b/src/client/state/entities.hh @@ -0,0 +1,21 @@ +#ifndef CLIENT_STATE_ENTITIES_HH_ +#define CLIENT_STATE_ENTITIES_HH_ + +#include <memory> +#include <unordered_map> + +#include "client/entity/entity.hh" + +namespace client { + +using entities_t = std::unordered_map<shared::entity::index_t, + std::unique_ptr<client::entity>>; + +namespace state { + +inline entities_t entities; + +} // namespace state +} // namespace client + +#endif diff --git a/src/client/state/state.cc b/src/client/state/state.cc new file mode 100644 index 0000000..2423c9a --- /dev/null +++ b/src/client/state/state.cc @@ -0,0 +1,15 @@ +#include "client/state/state.hh" + +namespace client { +namespace state { + +shared::time_duration_t get_time_per_tick() noexcept { + return std::chrono::microseconds(1'000'000) / tickrate; +} + +bool has_initialised() noexcept { + return state::localplayer_index.has_value(); +} + +} // namespace state +} // namespace client diff --git a/src/client/state/state.hh b/src/client/state/state.hh new file mode 100644 index 0000000..cfbb440 --- /dev/null +++ b/src/client/state/state.hh @@ -0,0 +1,41 @@ +#ifndef CLIENT_STATE_STATE_HH_ +#define CLIENT_STATE_STATE_HH_ + +#include <optional> + +#include "shared/entity/entity.hh" +#include "shared/net/connection.hh" +#include "shared/shared.hh" + +namespace client { +namespace state { + +inline std::string_view address; +inline std::string_view port; +inline std::uint64_t seed; +inline std::size_t player_count; +inline std::size_t requested_chunk_count; +inline std::size_t networked_chunk_count; +inline std::int32_t draw_distance; +inline std::int32_t chunks_per_frame; +inline std::uint32_t tickrate; + +inline shared::tick_t tick; +inline float delta_ticks; // num ticks since the last tick, [0, inf) +shared::time_duration_t get_time_per_tick() noexcept; + +// Speed of the client's move ticks should be 1.0f but if we're too slow (or the +// server lags and we're too fast) this value should move to speed up the client +// somewhat gracefully. +inline float time_factor = 1.0f; + +inline shared::net::connection* connection = nullptr; + +// non-opt after init +inline std::optional<shared::entity::index_t> localplayer_index; +bool has_initialised() noexcept; + +} // namespace state +} // namespace client + +#endif diff --git a/src/client/window.cc b/src/client/window.cc deleted file mode 100644 index 6a11252..0000000 --- a/src/client/window.cc +++ /dev/null @@ -1,449 +0,0 @@ -#include "window.hh" - -namespace client { -namespace window { - -// All window objects should derive from basic_window, and make use of multiple -// inheritance for specific behaviours. -class basic_window { -protected: - // Colours borrowed from arc-dark(er). - static constexpr glm::vec3 primary_clr{0.21f, 0.23f, 0.29f}; // dark - static constexpr glm::vec3 secondary_clr{0.29f, 0.32f, 0.38f}; // less dark - static constexpr glm::vec3 tertiary_clr{0.48, 0.50, 0.54}; // less dark ^2 - static constexpr glm::vec3 highlight_clr{0.32, 0.58, 0.88}; // light blue - static constexpr glm::vec3 font_colour{0.88, 0.88, 0.88}; // light grey - -protected: - glm::vec2 pos; - glm::vec2 size; - -public: - bool is_inside(const glm::vec2& v) const noexcept { - if (v.x < this->pos.x || v.x > this->pos.x + this->size.x) { - return false; - } - if (v.y < this->pos.y || v.y > this->pos.y + this->size.y) { - return false; - } - return true; - } - -public: - basic_window(const client::draw::relative_arg& p, - const client::draw::relative_arg& s) noexcept - : pos(p.to_vec2()), size(s.to_vec2()) {} - virtual ~basic_window() noexcept {} - - virtual bool maybe_handle_event(const SDL_Event&) noexcept { return false; } - virtual void draw() noexcept { - client::draw::draw_rectangle({.pos = {.offset = this->pos + 6.0f}, - .size = {.offset = this->size}, - .colour = {this->tertiary_clr, 0.9f}}); - client::draw::draw_rectangle({.pos = {.offset = this->pos}, - .size = {.offset = this->size}, - .colour = {this->primary_clr, 1.0f}}); - } -}; - -static void remove_top_layer() noexcept; -class text_input_window : public basic_window { -private: - // text restricted to a size of 32. - static const std::string& get_send_text() noexcept { - auto& text = client::input::state.text_input; - text = std::string{std::begin(text), - std::begin(text) + - static_cast<long>(std::min( - std::size(text), shared::MAX_SAY_LENGTH))}; - return text; - } - static bool maybe_handle_keydown(const SDL_Event& event) noexcept { - if (event.key.keysym.sym == SDLK_BACKSPACE) { - if (!client::input::state.text_input.empty()) { - client::input::state.text_input.pop_back(); - } - return true; - } - - if (event.key.keysym.sym != SDLK_RETURN || event.key.repeat) { - return false; - } - - if (!client::input::state.text_input.empty()) { - client::send_say_packet(get_send_text()); - } - - remove_top_layer(); // DELETE ME - return true; - } - static const glm::vec3& get_draw_colour() noexcept { - if (client::input::state.text_input.length() >= - shared::MAX_SAY_LENGTH) { - return basic_window::highlight_clr; - } - return basic_window::primary_clr; - } - -public: - template <typename... Args> - text_input_window(Args&&... args) noexcept - : basic_window(std::forward<Args>(args)...) { - client::input::set_text_input(true); - } - virtual ~text_input_window() noexcept { - client::input::set_text_input(false); - } - virtual bool maybe_handle_event(const SDL_Event& event) noexcept override { - switch (event.type) { - case SDL_KEYDOWN: - return this->maybe_handle_keydown(event); - } - - return basic_window::maybe_handle_event(event); - } - - virtual void draw() noexcept override { - basic_window::draw(); - - client::draw::draw_rectangle( - {.pos = {.offset = this->pos}, - .size = {.offset = this->size}, - .colour = {this->get_draw_colour(), 1.0f}}); - - client::draw::draw_text( - this->get_send_text(), - {.pos = {.extent = {0.0f, 0.0f}, - .offset = this->pos + (this->size / 2.0f)}, - .offset_height = this->size.y / 2.0f, - .colour = {this->font_colour, 1.0f}, - .has_backing = false, - .is_centered = true, - .is_vcentered = true}); - }; -}; - -class button_window : public basic_window { -protected: - std::string name; - std::function<void()> callback; - bool is_pressed; - -private: - void handle_mousebuttondown(const SDL_Event& event) noexcept { - if (event.button.button != SDL_BUTTON_LEFT) { - return; - } - this->is_pressed = true; - } - void handle_mousebuttonup(const SDL_Event& event) noexcept { - if (event.button.button != SDL_BUTTON_LEFT) { - return; - } - if (!this->is_pressed) { - return; - } - this->is_pressed = false; - std::invoke(this->callback); // edge - } - const glm::vec3& get_draw_colour() noexcept { - if (!this->is_inside(client::input::state.mouse_pos)) { - this->is_pressed = false; - return this->primary_clr; - } - - if (!this->is_pressed) { - return this->secondary_clr; - } - - return this->highlight_clr; - } - -public: - template <typename... Args> - button_window(const std::string_view n, const decltype(callback)& c, - Args&&... args) noexcept - : basic_window(std::forward<Args>(args)...), name(n), callback(c) {} - - virtual bool maybe_handle_event(const SDL_Event& event) noexcept override { - if (this->is_inside(client::input::state.mouse_pos)) { - switch (event.type) { - case SDL_MOUSEBUTTONDOWN: - this->handle_mousebuttondown(event); - return true; - case SDL_MOUSEBUTTONUP: - this->handle_mousebuttonup(event); - return true; - } - } - - return basic_window::maybe_handle_event(event); - } - virtual void draw() noexcept override { - basic_window::draw(); - - client::draw::draw_rectangle( - {.pos = {.offset = this->pos}, - .size = {.offset = this->size}, - .colour = {this->get_draw_colour(), 1.0f}}); - client::draw::draw_text( - this->name, {.pos = {.extent = {0.0f, 0.0f}, - .offset = this->pos + (this->size / 2.0f)}, - .offset_height = this->size.y / 2.0f, - .colour = {this->font_colour, 1.0f}, - .has_backing = false, - .is_centered = true, - .is_vcentered = true}); - }; -}; - -// Sliders are for numerical values of some type T. -// TODO -/* -template <typename T> -class slider_window : public basic_window { -protected: - std::string name; - T min; - T cur; - T max; - T& var; - -private: - void handle_mousebuttondown(const SDL_Event& event) noexcept {} - void handle_mousebuttonup(const SDL_Event& event) noexcept {} - -public: - template <typename... Args> - slider_window(const std::string_view name, const T& min, const T& cur, - const T& max, T& var, Args&&... args) noexcept - : basic_window(std::forward<Args>(args)...), name(name), min(min), - cur(cur), max(max), var(var) {} - - // slider_window( - virtual bool maybe_handle_event(const SDL_Event& event) noexcept -override { switch (event.type) { case SDL_MOUSEBUTTONDOWN: - this->handle_mousebuttondown(event); - return true; - case SDL_MOUSEBUTTONUP: - this->handle_mousebuttonup(event); - return true; - } - return basic_window::maybe_handle_event(event); - } - virtual void draw() noexcept override { basic_window::draw(); } -}; -*/ - -static void handle_event(const SDL_Event& event) noexcept; // ignore - -// All windows go in this list! -using layer = std::forward_list<std::unique_ptr<basic_window>>; -using layers = std::forward_list<layer>; -static layers& get_layers() noexcept { - // We callbacks for our window manager are initialised here too. - static layers ret = []() -> layers { - client::input::register_event_handler(&handle_event); - client::input::set_text_input(false); - client::input::set_mouse_relative(true); - return {}; - }(); - return ret; -} - -static void remove_top_layer() noexcept { - if (!get_layers().empty()) { - get_layers().pop_front(); - } - // Our windows might be empty here, so set our mouse mode accordingly. - if (!client::window::is_open()) { - client::input::set_mouse_relative(true); - } -} - -// Constants used for uniform ui sizes. -constexpr glm::vec2 lsize_extent{0.4, 0.075}; -constexpr glm::vec2 ssize_extent{0.15, 0.075}; - -static void center_mouse_position() noexcept { - const glm::vec2& window = client::render::get_window_size(); - client::input::set_mouse_position({window.x / 2.0f, window.y / 2.0f}); -} - -template <typename T, typename... Args> -void push_window(Args&&... args) noexcept { - get_layers().front().push_front( - std::make_unique<T>(std::forward<Args>(args)...)); -} - -constexpr glm::vec2 center_extent(const glm::vec2 pos, - const glm::vec2 size) noexcept { - return {pos.x, pos.y - size.y / 2.0f}; -} - -static void make_options_menu() noexcept { - get_layers().push_front({}); - - /* - push_window<::slider_window<float>>( - "Field of Vision", 0.0f, - settings::get(std::make_pair("gameplay", "fov"), 100.0f), 145.0f, - remove_top_layer, - client::draw::relative_arg{.extent = - center_extent({0.3, 0.7}, - lsize_extent)}, client::draw::relative_arg{.extent = lsize_extent}); - */ - - push_window<button_window>( - "Back", remove_top_layer, - client::draw::relative_arg{.extent = - center_extent({0.3, 0.3}, ssize_extent)}, - client::draw::relative_arg{.extent = ssize_extent}); -} - -static void make_main_menu() noexcept { - get_layers().push_front({}); - - push_window<button_window>( - "Return to Game", remove_top_layer, - client::draw::relative_arg{.extent = - center_extent({0.3, 0.7}, lsize_extent)}, - client::draw::relative_arg{.extent = lsize_extent}); - - push_window<button_window>( - "Options", make_options_menu, - client::draw::relative_arg{ - .extent = center_extent({0.55, 0.6}, ssize_extent)}, - client::draw::relative_arg{.extent = ssize_extent}); - - push_window<button_window>( - "?", remove_top_layer, - client::draw::relative_arg{ - .extent = center_extent({0.55, 0.5}, ssize_extent)}, - client::draw::relative_arg{.extent = ssize_extent}); - - push_window<button_window>( - "?", remove_top_layer, - client::draw::relative_arg{ - .extent = center_extent({0.55, 0.4}, ssize_extent)}, - client::draw::relative_arg{.extent = ssize_extent}); - - push_window<button_window>( - "Exit Game", [] { shared::should_exit = true; }, - client::draw::relative_arg{.extent = - center_extent({0.3, 0.3}, lsize_extent)}, - client::draw::relative_arg{.extent = lsize_extent}); - - client::input::set_mouse_relative(false); - center_mouse_position(); -} - -static void make_chat_window() noexcept { - get_layers().push_front({}); - - push_window<text_input_window>( - client::draw::relative_arg{.extent = - center_extent({0.3, 0.3}, lsize_extent)}, - client::draw::relative_arg{.extent = lsize_extent}); - - client::input::set_mouse_relative(false); - center_mouse_position(); -} - -static void handle_meta_return() noexcept { - if (!is_open()) { - make_chat_window(); - return; - } -} - -static void handle_meta_escape() noexcept { - if (!is_open()) { - make_main_menu(); - return; - } - - remove_top_layer(); -} - -static void handle_meta_keydown(const SDL_Event& event) noexcept { - if (event.key.repeat) { // only handle keypresses - return; - } - - switch (event.key.keysym.sym) { - case SDLK_ESCAPE: - handle_meta_escape(); - break; - case SDLK_RETURN: - handle_meta_return(); - break; - } -} - -static void handle_meta_mousemotion(const SDL_Event& event) noexcept { - // We convert SDL's weird coordinates into useful ones (0,0 = bottom - // left). - client::input::state.mouse_pos = { - event.motion.x, - static_cast<int>(client::render::get_window_size().y) - event.motion.y}; -} - -static void handle_meta_windowevent(const SDL_Event& event) noexcept { - if (event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) { - if (!is_open()) { - make_main_menu(); - return; - } - } -} - -static void handle_meta_event(const SDL_Event& event) noexcept { - switch (event.type) { - case SDL_KEYDOWN: - handle_meta_keydown(event); - break; - case SDL_MOUSEMOTION: - handle_meta_mousemotion(event); - break; - case SDL_WINDOWEVENT: - handle_meta_windowevent(event); - break; - } -} - -static void handle_event(const SDL_Event& event) noexcept { - // We ALWAYS update our mouse position. - if (event.type == SDL_MOUSEMOTION) { - handle_meta_mousemotion(event); - } - - // Either a window consumes our event, or no window does - so we send - // the event to our "meta handler" which does things like closing - // windows etc. - if (is_open()) { - for (const auto& window : get_layers().front()) { - if (window->maybe_handle_event(event)) { - return; - } - } - } - - handle_meta_event(event); -} - -void draw() noexcept { - if (!is_open()) { - return; - } - - client::draw::draw_colour({0.0f, 0.0f, 0.0f, 0.10f}); // very light shade - for (const auto& window : get_layers().front()) { - window->draw(); - } -} - -bool is_open() noexcept { return !get_layers().empty(); } - -} // namespace window -} // namespace client diff --git a/src/client/window/basic_window.cc b/src/client/window/basic_window.cc new file mode 100644 index 0000000..c96f94a --- /dev/null +++ b/src/client/window/basic_window.cc @@ -0,0 +1,33 @@ +#include "client/window/basic_window.hh" + +namespace client { +namespace window { + +using bw = basic_window; + +bool bw::is_inside(const glm::vec2& v, const glm::vec2& p, + const glm::vec2& s) noexcept { + if (v.x < p.x || v.x > p.x + s.x) { + return false; + } + if (v.y < p.y || v.y > p.y + s.y) { + return false; + } + return true; +} + +bool bw::is_inside(const glm::vec2& v) const noexcept { + return is_inside(v, this->pos, this->size); +} + +void bw::draw() noexcept { + client::render::draw_rectangle({.pos = {.offset = this->pos + 6.0f}, + .size = {.offset = this->size}, + .colour = {this->tertiary_clr, 0.9f}}); + client::render::draw_rectangle({.pos = {.offset = this->pos}, + .size = {.offset = this->size}, + .colour = {this->primary_clr, 1.0f}}); +} + +} // namespace window +} // namespace client diff --git a/src/client/window/basic_window.hh b/src/client/window/basic_window.hh new file mode 100644 index 0000000..292cc64 --- /dev/null +++ b/src/client/window/basic_window.hh @@ -0,0 +1,52 @@ +#ifndef CLIENT_WINDOW_BASIC_WINDOW_HH_ +#define CLIENT_WINDOW_BASIC_WINDOW_HH_ + +#include <glm/glm.hpp> + +#include "client/entity/player.hh" +#include "client/render/render.hh" +#include "client/render/struct.hh" + +namespace client { +namespace window { + +// All window objects should derive from basic_window, and make use of multiple +// inheritance for specific behaviours. +class basic_window { +protected: + // Colours borrowed from arc-dark(er). + static constexpr glm::vec3 primary_clr{0.21f, 0.23f, 0.29f}; // dark + static constexpr glm::vec3 secondary_clr{0.29f, 0.32f, 0.38f}; // less dark + static constexpr glm::vec3 tertiary_clr{0.48, 0.50, 0.54}; // less dark ^2 + static constexpr glm::vec3 highlight_clr{0.32, 0.58, 0.88}; // light blue + static constexpr glm::vec3 font_colour{0.88, 0.88, 0.88}; // light grey + +protected: + static constexpr float OUTLINE_WIDTH = 2.0f; + float get_item_size() const noexcept { return this->size.x / 10.0f; } + +protected: + glm::vec2 pos; + glm::vec2 size; + +public: + // Test if a vec2 v is inside a square starting at position p with size s. + static bool is_inside(const glm::vec2& v, const glm::vec2& p, + const glm::vec2& s) noexcept; + // Test if v is inside this->pos, this->size + bool is_inside(const glm::vec2& v) const noexcept; + +public: + basic_window(const client::render::relative_arg& pos, + const client::render::relative_arg& size) noexcept + : pos(pos.to_vec2()), size(size.to_vec2()) {} + virtual ~basic_window() noexcept {} + + virtual bool maybe_handle_event(const SDL_Event&) noexcept { return false; } + virtual void draw() noexcept; +}; + +} // namespace window +} // namespace client + +#endif diff --git a/src/client/window/button_window.cc b/src/client/window/button_window.cc new file mode 100644 index 0000000..4743c0a --- /dev/null +++ b/src/client/window/button_window.cc @@ -0,0 +1,71 @@ +#include "client/window/button_window.hh" + +namespace client { +namespace window { + +using bw = class button_window; + +void bw::handle_mousebuttondown(const SDL_Event& event) noexcept { + if (event.button.button != SDL_BUTTON_LEFT) { + return; + } + this->is_pressed = true; +} + +void bw::handle_mousebuttonup(const SDL_Event& event) noexcept { + if (event.button.button != SDL_BUTTON_LEFT) { + return; + } + if (!this->is_pressed) { + return; + } + this->is_pressed = false; + std::invoke(this->callback); // edge +} + +const glm::vec3& bw::get_draw_colour() noexcept { + if (!this->is_inside(client::input::state.mouse_pos)) { + this->is_pressed = false; + return this->primary_clr; + } + + if (!this->is_pressed) { + return this->secondary_clr; + } + + return this->highlight_clr; +} + +bool bw::maybe_handle_event(const SDL_Event& event) noexcept { + if (this->is_inside(client::input::state.mouse_pos)) { + switch (event.type) { + case SDL_MOUSEBUTTONDOWN: + this->handle_mousebuttondown(event); + return true; + case SDL_MOUSEBUTTONUP: + this->handle_mousebuttonup(event); + return true; + } + } + + return basic_window::maybe_handle_event(event); +} + +void bw::draw() noexcept { + basic_window::draw(); + + client::render::draw_rectangle({.pos = {.offset = this->pos}, + .size = {.offset = this->size}, + .colour = {this->get_draw_colour(), 1.0f}}); + client::render::draw_text( + this->name, {.pos = {.extent = {0.0f, 0.0f}, + .offset = this->pos + (this->size / 2.0f)}, + .offset_height = this->size.y / 2.0f, + .colour = {this->font_colour, 1.0f}, + .has_backing = false, + .is_centered = true, + .is_vcentered = true}); +}; + +} // namespace window +} // namespace client diff --git a/src/client/window/button_window.hh b/src/client/window/button_window.hh new file mode 100644 index 0000000..6847696 --- /dev/null +++ b/src/client/window/button_window.hh @@ -0,0 +1,40 @@ +#ifndef CLIENT_WINDOW_BUTTON_WINDOW_HH_ +#define CLIENT_WINDOW_BUTTON_WINDOW_HH_ + +#include <functional> +#include <string> + +#include "client/input.hh" +#include "client/render/render.hh" +#include "client/window/basic_window.hh" + +namespace client { +namespace window { + +class button_window : public basic_window { +protected: + std::string name; + std::function<void()> callback; + bool is_pressed; + +private: + void handle_mousebuttondown(const SDL_Event& event) noexcept; + void handle_mousebuttonup(const SDL_Event& event) noexcept; + const glm::vec3& get_draw_colour() noexcept; + +public: + template <typename... Args> + button_window(const std::string_view n, const decltype(callback)& c, + Args&&... args) noexcept + : basic_window(std::forward<Args>(args)...), name(n), callback(c), + is_pressed(false) {} + virtual ~button_window() noexcept {} + + virtual bool maybe_handle_event(const SDL_Event& event) noexcept override; + virtual void draw() noexcept override; +}; + +} // namespace window +} // namespace client + +#endif diff --git a/src/client/window/hud_window.cc b/src/client/window/hud_window.cc new file mode 100644 index 0000000..52995ca --- /dev/null +++ b/src/client/window/hud_window.cc @@ -0,0 +1,88 @@ +#include "client/window/hud_window.hh" + +namespace client { +namespace window { + +using hw = class hud_window; +bool hw::maybe_handle_keydown(const SDL_Event& event) noexcept { + const auto& sym = event.key.keysym.sym; + const auto index = static_cast<int>(sym); + + const auto min = static_cast<int>(SDLK_0); + const auto max = static_cast<int>(SDLK_9); + if (index < min || index > max) { + return false; + } + + const auto active = + static_cast<std::uint32_t>((((sym - min) - 1) + 10) % 10); + client::get_localplayer().get_mutable_active_item() = active; + return true; +} + +bool hw::maybe_handle_event(const SDL_Event& event) noexcept { + if (is_open()) { + return false; + } + + switch (event.type) { + case SDL_KEYDOWN: + return this->maybe_handle_keydown(event); + default: + break; + } + return false; +} + +void hw::draw() noexcept { + this->basic_window::draw(); + + const float item_size = this->get_item_size(); + + const auto& localplayer = client::get_localplayer(); + client::render::draw_rectangle( + {.pos = {.offset = {this->pos.x + static_cast<float>( + localplayer.get_active_item()) * + item_size, + this->pos.y}}, + .size = {.offset = {item_size, item_size}}, + .colour = {this->secondary_clr, 1.0f}}); + + for (int i = 1; i < shared::player::INVENTORY_COLS; ++i) { + const float off = item_size * static_cast<float>(i); + client::render::draw_rectangle( + {.pos = {.offset = {this->pos.x + off, + this->pos.y + OUTLINE_WIDTH}}, + .size = {.offset = {OUTLINE_WIDTH, + item_size - 2.0f * OUTLINE_WIDTH}}, + .colour = {this->tertiary_clr, 1.0f}}); + } + + const auto& inventory = localplayer.inventory; + for (int x = 0; x < shared::player::INVENTORY_COLS; ++x) { + const auto& item = inventory.contents[static_cast<unsigned long>(x)]; + if (item == nullptr) { + continue; + } + + const glm::vec2 off{glm::vec2{x, 0} * item_size}; + const auto item_ptr = dynamic_cast<client::item::item*>(&*item); + if (item_ptr == nullptr) { + continue; + } + item_ptr->draw(this->pos + off, glm::vec2{item_size, item_size}); + + client::render::draw_text( + std::to_string(item->quantity), + {.pos = {.offset = this->pos + off + + glm::vec2{item_size * 0.75f, item_size * 0.2f}}, + .offset_height = item_size * 0.40f, + .colour = {this->font_colour, 1.0f}, + .has_backing = false, + .is_centered = true, + .is_vcentered = true}); + } +} + +} // namespace window +} // namespace client diff --git a/src/client/window/hud_window.hh b/src/client/window/hud_window.hh new file mode 100644 index 0000000..7c03e0e --- /dev/null +++ b/src/client/window/hud_window.hh @@ -0,0 +1,32 @@ +#ifndef CLIENT_WINDOW_HUD_WINDOW_HH_ +#define CLIENT_WINDOW_HUD_WINDOW_HH_ + +#include "client/render/struct.hh" +#include "client/window/basic_window.hh" +#include "client/window/window.hh" +#include "shared/entity/player.hh" + +namespace client { +namespace window { + +class hud_window : public basic_window { + +private: + bool maybe_handle_keydown(const SDL_Event& event) noexcept; + +public: + template <typename... Args> + hud_window(const float size) noexcept + : basic_window( + client::render::relative_arg{.extent = {0.5f, 0.0f}, + .offset = {-size / 2.0f, 0.0f}}, + client::render::relative_arg{.offset = {size, size / 10.0f}}) {} + + virtual void draw() noexcept override; + virtual bool maybe_handle_event(const SDL_Event& event) noexcept override; +}; + +} // namespace window +} // namespace client + +#endif diff --git a/src/client/window/inventory_window.cc b/src/client/window/inventory_window.cc new file mode 100644 index 0000000..5023f1d --- /dev/null +++ b/src/client/window/inventory_window.cc @@ -0,0 +1,196 @@ +#include "client/window/inventory_window.hh" + +namespace client { +namespace window { + +using iw = class inventory_window; + +bool iw::maybe_handle_mousebuttondown(const SDL_Event& event) noexcept { + + if (event.button.button != SDL_BUTTON_LEFT) { + return false; + } + if (!this->is_inside(client::input::state.mouse_pos)) { + return false; + } + + const auto index = + this->maybe_get_inventory_index(client::input::state.mouse_pos); + if (!index.has_value()) { + return false; + } + + const auto& inventory = client::get_localplayer().inventory; + if (inventory.contents[*index] != nullptr) { + this->grabbed.emplace(*index); + } + return true; +} + +static proto::packet make_swap_packet(const std::uint32_t& a, + const std::uint32_t& b) noexcept { + proto::packet ret; + const auto packet = ret.mutable_item_swap_packet(); + packet->set_index_a(a); + packet->set_index_b(b); + return ret; +} + +bool iw::maybe_handle_mousebuttonup(const SDL_Event& event) noexcept { + + if (event.button.button != SDL_BUTTON_LEFT) { + return false; + } + if (!this->grabbed.has_value()) { + return false; + } + + if (const auto index = + this->maybe_get_inventory_index(input::state.mouse_pos); + index.has_value() && index != *grabbed) { + + auto& inventory = client::get_localplayer().inventory; + std::swap(inventory.contents[*grabbed], inventory.contents[*index]); + + // replicate on server + state::connection->rsend_packet( + make_swap_packet(static_cast<std::uint32_t>(*grabbed), + static_cast<std::uint32_t>(*index))); + } + + this->grabbed.reset(); + return true; +} + +std::optional<unsigned long> +iw::maybe_get_inventory_index(const glm::vec2& pos) const noexcept { + + const float item_size = this->get_item_size(); + for (int x = 0; x < shared::player::INVENTORY_COLS; ++x) { + for (int y = 0; y < shared::player::INVENTORY_ROWS; ++y) { + const glm::vec2 off{this->pos + + glm::vec2{OUTLINE_WIDTH, OUTLINE_WIDTH} + + glm::vec2{x, y} * item_size}; + if (!basic_window::is_inside(pos, off, + glm::vec2{item_size, item_size})) { + continue; + } + return x + y * shared::player::INVENTORY_COLS; + } + } + return std::nullopt; +} + +bool iw::maybe_handle_event(const SDL_Event& event) noexcept { + switch (event.type) { + case SDL_MOUSEBUTTONDOWN: + return this->maybe_handle_mousebuttondown(event); + case SDL_MOUSEBUTTONUP: + return this->maybe_handle_mousebuttonup(event); + } + + return basic_window::maybe_handle_event(event); +} + +void iw::draw() noexcept { + basic_window::draw(); + + const float item_size = this->get_item_size(); + + const auto& localplayer = client::get_localplayer(); + client::render::draw_rectangle( + {.pos = {.offset = {this->pos.x + static_cast<float>( + localplayer.get_active_item()) * + item_size, + this->pos.y}}, + .size = {.offset = {item_size, item_size}}, + .colour = {this->secondary_clr, 1.0f}}); + for (int i = 1; i < shared::player::INVENTORY_COLS; ++i) { + const float off = item_size * static_cast<float>(i); + client::render::draw_rectangle( + {.pos = {.offset = {this->pos.x + off, + this->pos.y + OUTLINE_WIDTH}}, + .size = {.offset = {OUTLINE_WIDTH, + item_size * shared::player::INVENTORY_ROWS - + OUTLINE_WIDTH}}, + .colour = {this->tertiary_clr, 1.0f}}); + + if (i <= shared::player::INVENTORY_ROWS) { + client::render::draw_rectangle( + {.pos = {.offset = {pos.x + OUTLINE_WIDTH, pos.y + off}}, + .size = {.offset = {this->size.x - 2.0f * OUTLINE_WIDTH, + OUTLINE_WIDTH}}, + .colour = {this->tertiary_clr, 1.0f}}); + } + } + + const auto& inventory = localplayer.inventory; + if (const auto index = + this->maybe_get_inventory_index(client::input::state.mouse_pos); + index.has_value()) { + const glm::vec2 off{glm::vec2{*index % shared::player::INVENTORY_COLS, + *index / shared::player::INVENTORY_COLS} * + item_size}; + client::render::draw_rectangle( + {.pos = {.offset = this->pos + off + + glm::vec2{OUTLINE_WIDTH, OUTLINE_WIDTH}}, + .size = {.offset = glm::vec2{item_size, item_size} - + glm::vec2{OUTLINE_WIDTH, OUTLINE_WIDTH}}, + .colour = {this->secondary_clr, 1.0f}}); + } + + for (int x = 0; x < shared::player::INVENTORY_COLS; ++x) { + for (int y = 0; y < shared::player::INVENTORY_ROWS; ++y) { + const auto index = static_cast<unsigned long>( + x + y * shared::player::INVENTORY_COLS); + const auto& item = inventory.contents[index]; + if (item == nullptr) { + continue; + } + if (this->grabbed.has_value() && *this->grabbed == index) { + continue; + } + + const glm::vec2 off{glm::vec2{x, y} * item_size}; + const auto item_ptr = dynamic_cast<client::item::item*>(&*item); + if (item_ptr == nullptr) { + continue; + } + item_ptr->draw(this->pos + off, glm::vec2{item_size, item_size}); + + client::render::draw_text( + std::to_string(item->quantity), + {.pos = {.offset = + this->pos + off + + glm::vec2{item_size * 0.75f, item_size * 0.2f}}, + .offset_height = item_size * 0.40f, + .colour = {this->font_colour, 1.0f}, + .has_backing = false, + .is_centered = true, + .is_vcentered = true}); + } + } + + if (this->grabbed.has_value()) { + const auto item_ptr = + dynamic_cast<client::item::item*>(&*inventory.contents[*grabbed]); + if (item_ptr != nullptr) { + item_ptr->draw(client::input::state.mouse_pos - + glm::vec2{item_size, item_size} * 0.5f, + glm::vec2{item_size, item_size}); + client::render::draw_text( + std::to_string(item_ptr->quantity), + {.pos = {.offset = + client::input::state.mouse_pos + + glm::vec2{item_size * 0.25f, item_size * -0.3f}}, + .offset_height = item_size * 0.40f, + .colour = {this->font_colour, 1.0f}, + .has_backing = false, + .is_centered = true, + .is_vcentered = true}); + } + } +} + +} // namespace window +} // namespace client diff --git a/src/client/window/inventory_window.hh b/src/client/window/inventory_window.hh new file mode 100644 index 0000000..a77ae2f --- /dev/null +++ b/src/client/window/inventory_window.hh @@ -0,0 +1,40 @@ +#ifndef CLIENT_WINDOW_INVENTORY_WINDOW_HH_ +#define CLIENT_WINDOW_INVENTORY_WINDOW_HH_ + +#include <cstdint> +#include <optional> + +#include "client/item/item.hh" +#include "client/render/draw.hh" +#include "client/state/state.hh" +#include "client/window/basic_window.hh" + +namespace client { +namespace window { + +class inventory_window : public basic_window { +private: + std::optional<unsigned long> grabbed; + +private: + std::optional<unsigned long> + maybe_get_inventory_index(const glm::vec2& pos) const noexcept; + +private: + bool maybe_handle_mousebuttondown(const SDL_Event& event) noexcept; + bool maybe_handle_mousebuttonup(const SDL_Event& event) noexcept; + +public: + template <typename... Args> + inventory_window(Args&&... args) noexcept + : basic_window(std::forward<Args>(args)...) {} + virtual ~inventory_window() noexcept {} + + virtual bool maybe_handle_event(const SDL_Event& event) noexcept override; + virtual void draw() noexcept override; +}; + +} // namespace window +} // namespace client + +#endif diff --git a/src/client/window/text_input_window.cc b/src/client/window/text_input_window.cc new file mode 100644 index 0000000..0d556a4 --- /dev/null +++ b/src/client/window/text_input_window.cc @@ -0,0 +1,81 @@ +#include "client/window/text_input_window.hh" + +namespace client { +namespace window { + +using tiw = class text_input_window; + +const std::string& tiw::get_send_text() noexcept { + auto& text = client::input::state.text_input; + text = std::string{std::begin(text), + std::begin(text) + + static_cast<long>(std::min(std::size(text), + shared::MAX_SAY_LENGTH))}; + return text; +} + +proto::packet tiw::make_say_packet() noexcept { + proto::packet packet; + + const auto sub_say_packet = packet.mutable_say_packet(); + sub_say_packet->set_text(get_send_text()); + + return packet; +} + +bool tiw::maybe_handle_keydown(const SDL_Event& event) noexcept { + if (event.key.keysym.sym == SDLK_BACKSPACE) { + if (!client::input::state.text_input.empty()) { + client::input::state.text_input.pop_back(); + } + return true; + } + + if (event.key.keysym.sym != SDLK_RETURN || event.key.repeat) { + return false; + } + + if (!client::input::state.text_input.empty()) { + client::state::connection->rsend_packet(make_say_packet()); + } + + pop_window(); + return true; +} + +const glm::vec3& tiw::get_draw_colour() noexcept { + if (client::input::state.text_input.length() >= shared::MAX_SAY_LENGTH) { + return basic_window::highlight_clr; + } + return basic_window::primary_clr; +} + +bool tiw::maybe_handle_event(const SDL_Event& event) noexcept { + switch (event.type) { + case SDL_KEYDOWN: + return this->maybe_handle_keydown(event); + } + + return basic_window::maybe_handle_event(event); +} + +void tiw::draw() noexcept { + basic_window::draw(); + + client::render::draw_rectangle({.pos = {.offset = this->pos}, + .size = {.offset = this->size}, + .colour = {this->get_draw_colour(), 1.0f}}); + + client::render::draw_text( + this->get_send_text(), + {.pos = {.extent = {0.0f, 0.0f}, + .offset = this->pos + (this->size / 2.0f)}, + .offset_height = this->size.y / 2.0f, + .colour = {this->font_colour, 1.0f}, + .has_backing = false, + .is_centered = true, + .is_vcentered = true}); +}; + +} // namespace window +} // namespace client diff --git a/src/client/window/text_input_window.hh b/src/client/window/text_input_window.hh new file mode 100644 index 0000000..edff672 --- /dev/null +++ b/src/client/window/text_input_window.hh @@ -0,0 +1,43 @@ +#ifndef CLIENT_WINDOW_TEXT_INPUT_WINDOW_HH_ +#define CLIENT_WINDOW_TEXT_INPUT_WINDOW_HH_ + +#include <string> + +#include "client/input.hh" +#include "client/shared.hh" +#include "client/state/state.hh" +#include "client/window/basic_window.hh" +#include "shared/net/proto.hh" + +namespace client { +namespace window { + +void pop_window() noexcept; // forward declaration + +class text_input_window : public basic_window { +private: + // text restricted to a size of 32. + static const std::string& get_send_text() noexcept; + static proto::packet make_say_packet() noexcept; + + static bool maybe_handle_keydown(const SDL_Event& event) noexcept; + static const glm::vec3& get_draw_colour() noexcept; + +public: + template <typename... Args> + text_input_window(Args&&... args) noexcept + : basic_window(std::forward<Args>(args)...) { + client::input::set_text_input(true); + } + virtual ~text_input_window() noexcept { + client::input::set_text_input(false); + } + virtual bool maybe_handle_event(const SDL_Event& event) noexcept override; + + virtual void draw() noexcept override; +}; + +} // namespace window +} // namespace client + +#endif diff --git a/src/client/window/window.cc b/src/client/window/window.cc new file mode 100644 index 0000000..648997f --- /dev/null +++ b/src/client/window/window.cc @@ -0,0 +1,318 @@ +#include "window.hh" + +namespace client { +namespace window { + +// TODO + +// Sliders are for numerical values of some type T. +// TODO +/* +template <typename T> +class slider_window : public basic_window { +protected: + std::string name; + T min; + T cur; + T max; + T& var; + +private: + void handle_mousebuttondown(const SDL_Event& event) noexcept {} + void handle_mousebuttonup(const SDL_Event& event) noexcept {} + +public: + template <typename... Args> + slider_window(const std::string_view name, const T& min, const T& cur, + const T& max, T& var, Args&&... args) noexcept + : basic_window(std::forward<Args>(args)...), name(name), min(min), + cur(cur), max(max), var(var) {} + + // slider_window( + virtual bool maybe_handle_event(const SDL_Event& event) noexcept +override { switch (event.type) { case SDL_MOUSEBUTTONDOWN: + this->handle_mousebuttondown(event); + return true; + case SDL_MOUSEBUTTONUP: + this->handle_mousebuttonup(event); + return true; + } + return basic_window::maybe_handle_event(event); + } + virtual void draw() noexcept override { basic_window::draw(); } +}; +*/ + +static void handle_event(const SDL_Event& event) noexcept; // ignore + +static hud_window& get_hud_window() noexcept { + static hud_window ret = []() { + const auto& window = client::render::get_window_size(); + const float size = std::min(static_cast<float>(window.x) / 2.0f, + static_cast<float>(window.y) / 2.0f); + client::window::hud_window ret{size}; + return ret; + }(); + return ret; +} + +// All dynamic windows go in this list! +using layer = std::forward_list<std::unique_ptr<basic_window>>; +using layers = std::forward_list<layer>; +static layers& get_layers() noexcept { + // We callbacks for our window manager are initialised here too. + static layers ret = []() -> layers { + client::input::register_event_handler(&handle_event); + client::input::set_text_input(false); + client::input::set_mouse_relative(true); + return {}; + }(); + return ret; +} + +void pop_window() noexcept { + if (!get_layers().empty()) { + get_layers().pop_front(); + } + // Our windows might be empty here, so set our mouse mode accordingly. + if (!client::window::is_open()) { + client::input::set_mouse_relative(true); + } +} + +// Constants used for uniform ui sizes. +constexpr glm::vec2 lsize_extent{0.4, 0.075}; +constexpr glm::vec2 ssize_extent{0.15, 0.075}; + +static void center_mouse_position() noexcept { + const glm::vec2& window = client::render::get_window_size(); + client::input::set_mouse_position({window.x / 2.0f, window.y / 2.0f}); +} + +template <typename T, typename... Args> +void push_window(Args&&... args) noexcept { + get_layers().front().push_front( + std::make_unique<T>(std::forward<Args>(args)...)); +} + +constexpr glm::vec2 center_extent(const glm::vec2 pos, + const glm::vec2 size) noexcept { + return {pos.x, pos.y - size.y / 2.0f}; +} + +static void make_options_menu() noexcept { + get_layers().push_front({}); + + /* + push_window<::slider_window<float>>( + "Field of Vision", 0.0f, + settings::get(std::make_pair("gameplay", "fov"), 100.0f), 145.0f, + pop_window, + client::draw::relative_arg{.extent = + center_extent({0.3, 0.7}, + lsize_extent)}, client::draw::relative_arg{.extent = lsize_extent}); + */ + + push_window<button_window>( + "Back", pop_window, + client::render::relative_arg{ + .extent = center_extent({0.3, 0.3}, ssize_extent)}, + client::render::relative_arg{.extent = ssize_extent}); +} + +static void make_main_menu() noexcept { + get_layers().push_front({}); + + push_window<button_window>( + "Return to Game", pop_window, + client::render::relative_arg{ + .extent = center_extent({0.3, 0.7}, lsize_extent)}, + client::render::relative_arg{.extent = lsize_extent}); + + push_window<button_window>( + "Options", make_options_menu, + client::render::relative_arg{ + .extent = center_extent({0.55, 0.6}, ssize_extent)}, + client::render::relative_arg{.extent = ssize_extent}); + + push_window<button_window>( + "?", pop_window, + client::render::relative_arg{ + .extent = center_extent({0.55, 0.5}, ssize_extent)}, + client::render::relative_arg{.extent = ssize_extent}); + + push_window<button_window>( + "?", pop_window, + client::render::relative_arg{ + .extent = center_extent({0.55, 0.4}, ssize_extent)}, + client::render::relative_arg{.extent = ssize_extent}); + + push_window<button_window>( + "Exit Game", [] { shared::should_exit = true; }, + client::render::relative_arg{ + .extent = center_extent({0.3, 0.3}, lsize_extent)}, + client::render::relative_arg{.extent = lsize_extent}); + + client::input::set_mouse_relative(false); + center_mouse_position(); +} + +static void make_chat_window() noexcept { + get_layers().push_front({}); + + push_window<text_input_window>( + client::render::relative_arg{ + .extent = center_extent({0.3, 0.3}, lsize_extent)}, + client::render::relative_arg{.extent = lsize_extent}); + + client::input::set_mouse_relative(false); + center_mouse_position(); +} + +static void make_inventory_window() noexcept { + get_layers().push_front({}); + + const glm::vec2& window = client::render::get_window_size(); + + const float size = std::min(window.x / 2.0f, window.y / 2.0f); + const glm::vec2 pos{(window - size) / 2.0f}; + + push_window<inventory_window>( + client::render::relative_arg{.offset = pos}, + client::render::relative_arg{.offset = glm::vec2{size, size}}); + client::input::set_mouse_relative(false); + center_mouse_position(); +} + +static void handle_meta_return() noexcept { + if (!is_open()) { + make_chat_window(); + return; + } +} + +static void handle_meta_escape() noexcept { + if (!is_open()) { + make_main_menu(); + return; + } + + pop_window(); +} + +static void handle_meta_e() noexcept { + if (!is_open()) { + make_inventory_window(); + return; + } + + // The inventory window must be open. + if (!dynamic_cast<inventory_window*>(&*get_layers().front().front())) { + return; + } + + pop_window(); +} + +static void handle_meta_keydown(const SDL_Event& event) noexcept { + if (event.key.repeat) { // only handle keypresses + return; + } + + switch (event.key.keysym.sym) { + case SDLK_ESCAPE: + handle_meta_escape(); + break; + case SDLK_RETURN: + handle_meta_return(); + break; + case SDLK_e: + handle_meta_e(); + break; + case SDLK_0: + case SDLK_1: + case SDLK_2: + case SDLK_3: + case SDLK_4: + case SDLK_5: + case SDLK_6: + case SDLK_7: + case SDLK_8: + case SDLK_9: + get_hud_window().maybe_handle_event(event); + default: + break; + } +} + +static void handle_meta_mousemotion(const SDL_Event& event) noexcept { + // We convert SDL's weird coordinates into useful ones (0,0 = bottom + // left). + client::input::state.mouse_pos = { + event.motion.x, + static_cast<int>(client::render::get_window_size().y) - event.motion.y}; +} + +static void handle_meta_windowevent(const SDL_Event& event) noexcept { + if (event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) { + if (!is_open()) { + make_main_menu(); + return; + } + } +} + +static void handle_meta_event(const SDL_Event& event) noexcept { + switch (event.type) { + case SDL_KEYDOWN: + handle_meta_keydown(event); + break; + case SDL_MOUSEMOTION: + handle_meta_mousemotion(event); + break; + case SDL_WINDOWEVENT: + handle_meta_windowevent(event); + break; + } +} + +static void handle_event(const SDL_Event& event) noexcept { + // We ALWAYS update our mouse position. + if (event.type == SDL_MOUSEMOTION) { + handle_meta_mousemotion(event); + } + + // Either a window consumes our event, or no window does - so we send + // the event to our "meta handler" which does things like closing + // windows etc. + if (is_open()) { + for (const auto& window : get_layers().front()) { + if (window->maybe_handle_event(event)) { + return; + } + } + } + + handle_meta_event(event); +} + +void draw() noexcept { + if (!is_open()) { + + if (!client::input::is_key_toggled(SDLK_F1)) { + get_hud_window().draw(); + } + + return; + } + + client::render::draw_colour({0.0f, 0.0f, 0.0f, 0.10f}); // very light shade + for (const auto& window : get_layers().front()) { + window->draw(); + } +} + +bool is_open() noexcept { return !get_layers().empty(); } + +} // namespace window +} // namespace client diff --git a/src/client/window.hh b/src/client/window/window.hh index 094c4ca..d112d18 100644 --- a/src/client/window.hh +++ b/src/client/window/window.hh @@ -1,5 +1,5 @@ -#ifndef CLIENT_WINDOW_HH_ -#define CLIENT_WINDOW_HH_ +#ifndef CLIENT_WINDOW_WINDOW_HH_ +#define CLIENT_WINDOW_WINDOW_HH_ #include <algorithm> #include <forward_list> @@ -13,17 +13,25 @@ #include <glm/glm.hpp> #include "client/client.hh" -#include "client/draw.hh" #include "client/input.hh" +#include "client/render/render.hh" #include "client/settings.hh" +#include "client/window/basic_window.hh" +#include "client/window/button_window.hh" +#include "client/window/hud_window.hh" +#include "client/window/inventory_window.hh" +#include "client/window/text_input_window.hh" #include "shared/shared.hh" namespace client { namespace window { -void draw() noexcept; +// removes the topmost window +void pop_window() noexcept; bool is_open() noexcept; +void draw() noexcept; + } // namespace window } // namespace client diff --git a/src/client/world.cc b/src/client/world.cc deleted file mode 100644 index 1ceb9fb..0000000 --- a/src/client/world.cc +++ /dev/null @@ -1,429 +0,0 @@ -#include "world.hh" - -namespace client { -namespace world { - -// Additional sanity checks for our atlas. -static void check_atlas(const client::render::texture& texture) { - if (texture.width % 6) { - throw std::runtime_error("invalid atlas; WIDTH is not divisible by 6"); - } - if (texture.height % (texture.width / 6)) { - throw std::runtime_error( - "invalid atlas, HEIGHT is not divisible by (WIDTH / 6)"); - } -} - -void chunk::render(const float world_x, const float world_z, - const pass& pass) noexcept { - const auto make_texture = []() -> GLuint { - GLuint texture = 0; - glActiveTexture(GL_TEXTURE1); - glGenTextures(1, &texture); - glBindTexture(GL_TEXTURE_2D_ARRAY, texture); - - glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, - GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, - GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, - GL_LINEAR_MIPMAP_LINEAR); - glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_ANISOTROPY, 16.0f); - - const client::render::texture stbi{"res/textures/atlas.png"}; - check_atlas(stbi); - const int face_size = stbi.width / 6; - - // 2D texture array, where our depth is our block face. - glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, face_size, face_size, - 6 * (stbi.height / face_size), 0, - stbi.channels == 3 ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, - nullptr); - - // Fill the 2D texture array. - // Because our image has multiple images on the x-axis and opengl - // expects a single image per axis, we must fill it in row by row. - const auto get_pixel_xy = [&stbi](const int x, const int y) { - return stbi.image + 4 * (y * stbi.width + x); - }; - for (int x = 0; x < 6; ++x) { - const int x_pixel = x * face_size; - - for (int y = 0; y < stbi.height / face_size; ++y) { - const int y_pixel = y * face_size; - - for (auto row = 0; row < face_size; ++row) { - glTexSubImage3D( - GL_TEXTURE_2D_ARRAY, 0, 0, row, x + y * 6, face_size, 1, - 1, GL_RGBA, GL_UNSIGNED_BYTE, - get_pixel_xy(x_pixel, row + y_pixel)); // pixel - } - } - } - - glGenerateMipmap(GL_TEXTURE_2D_ARRAY); - - return texture; - }; - const auto make_matrix = [&]() -> glm::mat4 { - const auto& proj = client::render::camera::get_proj(); - const auto& view = client::render::camera::get_view(); - return glm::translate(proj * view, glm::vec3{world_x, 0, world_z}); - }; - static client::render::program program{"res/shaders/face.vs", - "res/shaders/face.fs"}; - static const GLuint texture [[maybe_unused]] = make_texture(); - static const GLint u_matrix = glGetUniformLocation(program, "_u_matrix"); - - glDisable(GL_BLEND); - glEnable(GL_DEPTH_TEST); - glUseProgram(program); - // Our choice of vao depends on which pass we're doing. - const auto [vao, elements] = [&pass, this]() -> std::pair<GLuint, GLuint> { - if (pass == pass::solid) { - return {this->glo->solid_vao, this->glo->solid_elements}; - } - return {this->glo->water_vao, this->glo->water_elements}; - }(); - glBindVertexArray(vao); - - glUniformMatrix4fv(u_matrix, 1, GL_FALSE, glm::value_ptr(make_matrix())); - - glDrawArrays(GL_TRIANGLES, 0, elements); -} - -// This function translates and rotates a set of vertices that describes a -// neutral face and also adds a vector to the texture coords. -std::array<chunk::glface, 6> -chunk::make_glfaces(const glface_args& args) noexcept { - - static constexpr std::array<glface, 6> glfaces = { - glface{{-0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}}, - glface{{0.5f, -0.5f, 0.0f}, {1.0f, 1.0f, 0.0f}}, - glface{{0.5f, 0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}}, - glface{{0.5f, 0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}}, - glface{{-0.5f, 0.5f, 0.0f}, {0.0f, 0.0f, 0.0f}}, - glface{{-0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}}}; - - // We have to be careful here not to rotate/translate a zero vector. - const glm::mat4 mtranslate = - args.translate == glm::vec3{} - ? glm::mat4{1.0f} - : glm::translate(glm::mat4{1.0f}, args.translate); - const glm::mat4 mrotate = - args.rotate_axis == glm::vec3{} - ? glm::mat4{1.0f} - : glm::rotate(glm::mat4{1.0f}, glm::radians(args.rotate_degrees), - args.rotate_axis); - - std::array<glface, 6> ret; - - std::ranges::transform(glfaces, std::begin(ret), [&](const auto f) { - auto face = f; // unfortunate copy - face.vertice = - glm::vec3(mtranslate * mrotate * glm::vec4{face.vertice, 1.0f}); - face.texture += args.texture_offset; - return face; - }); - - return ret; -} - -const chunk* chunk::get_neighbour(const chunk::map& chunks, - shared::math::coords offset) const noexcept { - const auto find_it = chunks.find(this->pos + offset); - if (find_it == std::end(chunks) || !find_it->second.has_value()) { - return nullptr; - } - return &((*find_it).second.value()); -} - -bool chunk::maybe_regenerate_glo(const chunk::map& chunks) noexcept { - // We need all surrounding chunks to make our vbo, this is why it's called - // "maybe" regenerate vbo. - const auto chunk_forward = this->get_neighbour(chunks, {0, 1}); - const auto chunk_backward = this->get_neighbour(chunks, {0, -1}); - const auto chunk_right = this->get_neighbour(chunks, {1, 0}); - const auto chunk_left = this->get_neighbour(chunks, {-1, 0}); - if (!chunk_forward || !chunk_left || !chunk_backward || !chunk_right) { - return false; - } - - static const auto [atlas_width, - atlas_height] = []() -> std::pair<int, int> { - const client::render::texture texture{"res/textures/atlas.png"}; - check_atlas(texture); - return {texture.width, texture.height}; - }(); - - // Single-axis-outside-chunk-bounds-allowed block access. - const auto get_outside_block = [&](const int x, const int y, - const int z) -> shared::world::block { - if (y < 0 || y >= shared::world::chunk::HEIGHT) { - return shared::world::block::type::air; - } else if (x >= shared::world::chunk::WIDTH) { - return chunk_right->get_block({x - WIDTH, y, z}); - } else if (x < 0) { - return chunk_left->get_block({x + WIDTH, y, z}); - } else if (z >= shared::world::chunk::WIDTH) { - return chunk_forward->get_block({x, y, z - WIDTH}); - } else if (z < 0) { - return chunk_backward->get_block({x, y, z + WIDTH}); - } - return this->get_block({x, y, z}); - }; - - // We fill up two vbos, one for each possible rendering pass. - std::vector<glface> solid_data; - std::vector<glface> water_data; - - // For all blocks in the chunk, check if its neighbours are air. If they - // are, it's possible that we can see the block, so add it to vertices. - // We need to read into the neighbours chunk occasionally. - for (auto x = 0; x < WIDTH; ++x) { - for (auto y = 0; y < HEIGHT; ++y) { - for (auto z = 0; z < WIDTH; ++z) { - const auto& block = this->get_block({x, y, z}); - const auto bv = shared::world::block::get_visibility(block); - - if (bv == shared::world::block::visibility::invisible) { - continue; - } - - const auto& front{get_outside_block(x, y, z + 1)}; - const auto& back{get_outside_block(x, y, z - 1)}; - const auto& right{get_outside_block(x + 1, y, z)}; - const auto& left{get_outside_block(x - 1, y, z)}; - const auto& up{get_outside_block(x, y + 1, z)}; - const auto& down{get_outside_block(x, y - 1, z)}; - - std::vector<glface> glfaces; - glfaces.reserve(6 * 6); - - const auto should_draw_face = [&bv](const auto& other) -> bool { - const auto ov = shared::world::block::get_visibility(other); - if (bv == shared::world::block::visibility::translucent && - ov == shared::world::block::visibility::translucent) { - return false; - } - return ov != shared::world::block::visibility::solid; - }; - // Special shrub block case, ugly I know. - if (block.type == shared::world::block::type::shrub || - block.type == shared::world::block::type::dead_shrub || - block.type == shared::world::block::type::snowy_shrub) { - static const auto front_shrub = - make_glfaces({.translate = {0.0f, 0.0f, 0.0f}, - .rotate_degrees = 45.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 0.0f}}); - static const auto right_shrub = - make_glfaces({.translate = {0.0f, 0.0f, 0.0f}, - .rotate_degrees = 135.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 0.0f}}); - static const auto back_shrub = - make_glfaces({.translate = {0.0f, 0.0f, 0.0f}, - .rotate_degrees = 225.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 0.0f}}); - static const auto left_shrub = - make_glfaces({.translate = {0.0f, 0.0f, 0.0f}, - .rotate_degrees = 315.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 0.0f}}); - - std::ranges::copy(front_shrub, std::back_inserter(glfaces)); - std::ranges::copy(right_shrub, std::back_inserter(glfaces)); - std::ranges::copy(back_shrub, std::back_inserter(glfaces)); - std::ranges::copy(left_shrub, std::back_inserter(glfaces)); - - } else { - if (should_draw_face(front)) { - static const auto front_faces = make_glfaces( - {.translate = {0.0f, 0.0f, 0.5f}, - .rotate_degrees = 0.0f, - .rotate_axis = {0.0f, 0.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 0.0f}}); - std::ranges::copy(front_faces, - std::back_inserter(glfaces)); - } - if (should_draw_face(right)) { - static const auto right_faces = make_glfaces( - {.translate = {0.5f, 0.0f, 0.0f}, - .rotate_degrees = 90.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 1.0f}}); - std::ranges::copy(right_faces, - std::back_inserter(glfaces)); - } - if (should_draw_face(back)) { - static const auto back_faces = make_glfaces( - {.translate = {0.0f, 0.0f, -0.5f}, - .rotate_degrees = 180.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 2.0f}}); - std::ranges::copy(back_faces, - std::back_inserter(glfaces)); - } - if (should_draw_face(left)) { - static const auto left_faces = make_glfaces( - {.translate = {-0.5f, 0.0f, 0.0f}, - .rotate_degrees = 270.0f, - .rotate_axis = {0.0f, 1.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 3.0f}}); - std::ranges::copy(left_faces, - std::back_inserter(glfaces)); - } - if (should_draw_face(up)) { - static const auto up_faces = make_glfaces( - {.translate = {0.0f, 0.5f, 0.0f}, - .rotate_degrees = -90.0f, - .rotate_axis = {1.0f, 0.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 4.0f}}); - std::ranges::copy(up_faces, - std::back_inserter(glfaces)); - } - if (should_draw_face(down)) { - static const auto down_faces = make_glfaces( - {.translate = {0.0f, -0.5f, 0.0f}, - .rotate_degrees = 90.0f, - .rotate_axis = {1.0f, 0.0f, 0.0f}, - .texture_offset = {0.0f, 0.0f, 5.0f}}); - std::ranges::copy(down_faces, - std::back_inserter(glfaces)); - } - } - - // Move the block pos verts to its intended position. - // Move the block texture verts to fit in the atlas. - const glm::vec3 offset_vec3{x, y, z}; - const float tex_yoff = static_cast<float>(block.type) - 1.0f; - - const auto fix_face = [&, atlas_width = std::ref(atlas_width), - atlas_height = - std::ref(atlas_height)](auto& face) { - face.vertice += offset_vec3 + 0.5f; // move to origin too - face.texture.z += tex_yoff * 6.0f; - return face; - }; - - auto& vbo_dest = block.type == shared::world::block::type::water - ? water_data - : solid_data; - std::ranges::transform(glfaces, std::back_inserter(vbo_dest), - fix_face); - } - } - } - - const auto generate_vbo = [](const auto& data) -> GLuint { - GLuint vbo = 0; - glGenBuffers(1, &vbo); - glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferData(GL_ARRAY_BUFFER, std::size(data) * sizeof(glface), - std::data(data), GL_STATIC_DRAW); - return vbo; - }; - const auto generate_vao = []() -> GLuint { - GLuint vao = 0; - glGenVertexArrays(1, &vao); - glBindVertexArray(vao); - // position - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, sizeof(glm::vec3) / sizeof(float), GL_FLOAT, - GL_FALSE, sizeof(glface), nullptr); - // texture - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, sizeof(glm::vec3) / sizeof(float), GL_FLOAT, - GL_FALSE, sizeof(glface), - reinterpret_cast<void*>(sizeof(glm::vec3))); - return vao; - }; - // If we were to emplace glo with these there is no guarantee that each - // function will be called in order (at least, for g++ it isn't). Therefore - // we need to call them in order first. - const auto solid_vbo = generate_vbo(solid_data); - const auto solid_vao = generate_vao(); - const auto water_vbo = generate_vbo(water_data); - const auto water_vao = generate_vao(); - this->glo.emplace(std::size(solid_data), solid_vbo, solid_vao, - std::size(water_data), water_vbo, water_vao); - return true; -} - -// http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-boxes/ -static bool box_in_frustum(const std::array<glm::vec3, 8>& points) noexcept { - const auto& frustum = client::render::camera::get_frustum(); - - for (const auto& plane : frustum) { - bool inside = false; - bool outside = false; - - for (const auto& point : points) { - const float distance = plane.x * point.x + plane.y * point.y + - plane.z * point.z + plane.w; - if (distance < 0.0f) { - outside = true; - } else { - inside = true; - } - - if (inside && outside) { - break; - } - } - - if (!inside) { - return false; - } - } - - return true; -}; - -static bool is_chunk_visible(const float world_x, - const float world_z) noexcept { - const std::array<glm::vec3, 8> box_vertices = - [&world_x, &world_z]() -> std::array<glm::vec3, 8> { - const float max_world_x = world_x + shared::world::chunk::WIDTH; - const float max_world_z = world_z + shared::world::chunk::WIDTH; - - return {glm::vec3{world_x, 0.0f, world_z}, - {max_world_x, 0.0f, world_z}, - {world_x, 0.0f, max_world_z}, - {max_world_x, 0.0f, max_world_z}, - {world_x, shared::world::chunk::HEIGHT, world_z}, - {max_world_x, shared::world::chunk::HEIGHT, world_z}, - {world_x, shared::world::chunk::HEIGHT, max_world_z}, - {max_world_x, shared::world::chunk::HEIGHT, max_world_z}}; - }(); - - return box_in_frustum(box_vertices); -} - -void chunk::draw(const chunk::map& chunks, const shared::player& lp, - const pass& pass) noexcept { - if (!this->glo.has_value() || this->should_regenerate_vbo) { - if (!maybe_regenerate_glo(chunks)) { - return; - } - this->should_regenerate_vbo = false; - } - - const auto [world_x, world_z] = [&lp, this]() -> std::pair<float, float> { - const float offset_x = static_cast<float>(this->pos.x - lp.chunk_pos.x); - const float offset_z = static_cast<float>(this->pos.z - lp.chunk_pos.z); - return {offset_x * chunk::WIDTH, offset_z * chunk::WIDTH}; - }(); - - if (!is_chunk_visible(world_x, world_z)) { - return; - } - - render(world_x, world_z, pass); -} - -} // namespace world -} // namespace client diff --git a/src/client/world/block.cc b/src/client/world/block.cc new file mode 100644 index 0000000..df3ddcd --- /dev/null +++ b/src/client/world/block.cc @@ -0,0 +1,117 @@ +#include "client/world/block.hh" + +namespace client { +namespace world { + +struct glvert_args { + glm::vec3 translate; + float rotate_degrees; + glm::vec3 rotate_axis; + glm::vec3 texture_offset; +}; +static block::glface_t make_glface(const glvert_args& args) noexcept { + static constexpr block::glface_t glverts = { + block::glvert{{-0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}}, + block::glvert{{0.5f, -0.5f, 0.0f}, {1.0f, 1.0f, 0.0f}}, + block::glvert{{0.5f, 0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}}, + block::glvert{{0.5f, 0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}}, + block::glvert{{-0.5f, 0.5f, 0.0f}, {0.0f, 0.0f, 0.0f}}, + block::glvert{{-0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}}}; + + // We have to be careful here not to rotate/translate a zero vector. + constexpr auto zero = glm::vec3{}; + const glm::mat4 mtranslate = + args.translate == zero + ? glm::mat4{1.0f} + : glm::translate(glm::mat4{1.0f}, args.translate); + const glm::mat4 mrotate = + args.rotate_axis == zero + ? glm::mat4{1.0f} + : glm::rotate(glm::mat4{1.0f}, glm::radians(args.rotate_degrees), + args.rotate_axis); + + block::glface_t ret; + std::ranges::transform(glverts, std::begin(ret), [&](auto f) { + f.vertice = + glm::vec3(mtranslate * mrotate * glm::vec4{f.vertice, 1.0f}); + f.texture += args.texture_offset; + return f; + }); + return ret; +} + +static const block::glfaces_t& get_shrub_faces() noexcept { + static block::glfaces_t faces{ + make_glface({.translate = {0.0f, 0.0f, 0.0f}, + .rotate_degrees = 45.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 0.0f}}), + make_glface({.translate = {0.0f, 0.0f, 0.0f}, + .rotate_degrees = 135.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 0.0f}}), + make_glface({.translate = {0.0f, 0.0f, 0.0f}, + .rotate_degrees = 225.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 0.0f}}), + make_glface({.translate = {0.0f, 0.0f, 0.0f}, + .rotate_degrees = 315.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 0.0f}})}; + return faces; +} + +static const block::glfaces_t& get_cube_faces() noexcept { + static block::glfaces_t faces{ + make_glface({.translate = {0.0f, 0.0f, 0.5f}, + .rotate_degrees = 0.0f, + .rotate_axis = {0.0f, 0.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 0.0f}}), + make_glface({.translate = {0.5f, 0.0f, 0.0f}, + .rotate_degrees = 90.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 1.0f}}), + make_glface({.translate = {0.0f, 0.0f, -0.5f}, + .rotate_degrees = 180.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 2.0f}}), + make_glface({.translate = {-0.5f, 0.0f, 0.0f}, + .rotate_degrees = 270.0f, + .rotate_axis = {0.0f, 1.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 3.0f}}), + make_glface({.translate = {0.0f, 0.5f, 0.0f}, + .rotate_degrees = -90.0f, + .rotate_axis = {1.0f, 0.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 4.0f}}), + make_glface({.translate = {0.0f, -0.5f, 0.0f}, + .rotate_degrees = 90.0f, + .rotate_axis = {1.0f, 0.0f, 0.0f}, + .texture_offset = {0.0f, 0.0f, 5.0f}}), + }; + return faces; +} + +enum block::draw_type +block::get_draw_type(const enum block::type& type) noexcept { + using t = enum shared::world::block::type; + switch (type) { + case t::dead_shrub: + case t::shrub: + case t::snowy_shrub: + return draw_type::custom; + default: + return draw_type::block; + } +} + +const block::glfaces_t& +block::get_glfaces(const enum block::type& type) noexcept { + const auto draw_type = get_draw_type(type); + if (draw_type == block::draw_type::custom) { + return get_shrub_faces(); + } + return get_cube_faces(); +} + +} // namespace world +} // namespace client diff --git a/src/client/world/block.hh b/src/client/world/block.hh new file mode 100644 index 0000000..9dfe303 --- /dev/null +++ b/src/client/world/block.hh @@ -0,0 +1,53 @@ +#ifndef CLIENT_WORLD_BLOCK_HH_ +#define CLIENT_WORLD_BLOCK_HH_ + +#include <algorithm> +#include <array> +#include <vector> + +#include <glm/glm.hpp> +#include <glm/gtc/matrix_access.hpp> +#include <glm/gtc/matrix_transform.hpp> + +#include "shared/world/block.hh" + +namespace client { +namespace world { + +// Doesn't add any data, just information for rendering. +class block : public shared::world::block { +public: + struct glvert { + glm::vec3 vertice; + glm::vec3 texture; + }; + using glface_t = std::array<glvert, 6>; // array of verts (a face) + using glfaces_t = std::vector<glface_t>; // vector of faces (a block) + + // Render types refer to how the block should be culled when making the vbo. + enum class draw_type { + block, // face testing + custom, // no testing + }; + +public: + static enum draw_type get_draw_type(const enum block::type& type) noexcept; + static const glfaces_t& get_glfaces(const enum block::type& type) noexcept; + +public: + template <typename... Args> + block(Args&&... args) noexcept : block(std::forward<Args>(args)...) {} + +public: + enum draw_type get_draw_type() const noexcept { + return get_draw_type(this->type); + } + const glfaces_t& get_glfaces() const noexcept { + return get_glfaces(this->type); + } +}; + +} // namespace world +} // namespace client + +#endif diff --git a/src/client/world/chunk.cc b/src/client/world/chunk.cc new file mode 100644 index 0000000..99720cb --- /dev/null +++ b/src/client/world/chunk.cc @@ -0,0 +1,255 @@ +#include "client/world/chunk.hh" + +namespace client { +namespace world { + +void chunk::render(const float world_x, const float world_z, + const pass& pass) noexcept { + const auto make_matrix = [&]() -> glm::mat4 { + const auto& proj = client::render::camera::get_proj(); + const auto& view = client::render::camera::get_view(); + return glm::translate(proj * view, glm::vec3{world_x, 0, world_z}); + }; + static client::render::program program{"res/shaders/face.vs", + "res/shaders/face.fs"}; + static const GLint u_matrix = glGetUniformLocation(program, "_u_matrix"); + + const GLuint texture [[maybe_unused]] = client::render::get_texture_atlas(); + glDisable(GL_BLEND); + glEnable(GL_DEPTH_TEST); + glUseProgram(program); + // Our choice of vao depends on which pass we're doing. + const auto [vao, elements] = [&pass, this]() -> std::pair<GLuint, GLuint> { + if (pass == pass::solid) { + return {this->glo->solid_vao, this->glo->solid_elements}; + } + return {this->glo->water_vao, this->glo->water_elements}; + }(); + glBindVertexArray(vao); + + glUniformMatrix4fv(u_matrix, 1, GL_FALSE, glm::value_ptr(make_matrix())); + + glDrawArrays(GL_TRIANGLES, 0, elements); +} + +const chunk* chunk::get_neighbour(const chunks_t& chunks, + shared::math::coords offset) const noexcept { + const auto find_it = chunks.find(this->pos + offset); + if (find_it == std::end(chunks) || !find_it->second.has_value()) { + return nullptr; + } + return &((*find_it).second.value()); +} + +bool chunk::maybe_regenerate_glo(const chunks_t& chunks) noexcept { + // We need all surrounding chunks to make our vbo, so early out with false + // if we can't do that yet. + const auto chunk_forward = this->get_neighbour(chunks, {0, 1}); + const auto chunk_backward = this->get_neighbour(chunks, {0, -1}); + const auto chunk_right = this->get_neighbour(chunks, {1, 0}); + const auto chunk_left = this->get_neighbour(chunks, {-1, 0}); + if (!chunk_forward || !chunk_left || !chunk_backward || !chunk_right) { + return false; + } + + // Single-axis-outside-chunk-bounds-allowed block access. + const auto get_outside_block = [&](const int x, const int y, + const int z) -> shared::world::block { + if (y < 0 || y >= shared::world::chunk::HEIGHT) { + return shared::world::block::type::air; + } else if (x >= shared::world::chunk::WIDTH) { + return chunk_right->get_block({x - WIDTH, y, z}); + } else if (x < 0) { + return chunk_left->get_block({x + WIDTH, y, z}); + } else if (z >= shared::world::chunk::WIDTH) { + return chunk_forward->get_block({x, y, z - WIDTH}); + } else if (z < 0) { + return chunk_backward->get_block({x, y, z + WIDTH}); + } + return this->get_block({x, y, z}); + }; + + // We fill up two vbos, one for each possible rendering pass. + std::vector<block::glvert> solid_data; + std::vector<block::glvert> water_data; + + // For all blocks in the chunk, check if its neighbours are air. If they + // are, it's possible that we can see the block, so add it to vertices. + // We need to read into the neighbours chunk occasionally. + for (auto x = 0; x < WIDTH; ++x) { + for (auto y = 0; y < HEIGHT; ++y) { + for (auto z = 0; z < WIDTH; ++z) { + const auto& block = this->get_block({x, y, z}); + const auto bv = shared::world::block::get_visibility(block); + + if (bv == shared::world::block::visibility::invisible) { + continue; + } + + std::vector<block::glvert> glverts; + glverts.reserve(6 * 6); + + const auto draw_type = block::get_draw_type(block.type); + + const block::glfaces_t& faces = block::get_glfaces(block.type); + if (draw_type == block::draw_type::block) { + const std::array<shared::world::block, 6> around{ + get_outside_block(x, y, z + 1), + get_outside_block(x + 1, y, z), + get_outside_block(x, y, z - 1), + get_outside_block(x - 1, y, z), + get_outside_block(x, y + 1, z), + get_outside_block(x, y - 1, z), + }; + + for (auto i = 0ul; i < std::size(faces); ++i) { + const auto ov = block::get_visibility(around[i]); + if (bv == block::visibility::translucent && + ov == block::visibility::translucent) { + continue; + } + if (ov == block::visibility::solid) { + continue; + } + + std::ranges::copy(faces[i], + std::back_inserter(glverts)); + } + } else if (draw_type == block::draw_type::custom) { + for (const auto& face : faces) { + std::ranges::copy(face, std::back_inserter(glverts)); + } + } + + // Move the block pos verts to its intended position. + // Move the block texture verts to fit in the atlas. + const glm::vec3 offset_vec3{x, y, z}; + const float tex_yoff = static_cast<float>(block.type) - 1.0f; + const auto fix_face = [&](auto& face) { + face.vertice += offset_vec3 + 0.5f; // move to origin too + face.texture.z += tex_yoff * 6.0f; + return face; + }; + + auto& vbo_dest = block.type == shared::world::block::type::water + ? water_data + : solid_data; + std::ranges::transform(glverts, std::back_inserter(vbo_dest), + fix_face); + } + } + } + + const auto generate_vbo = [](const auto& data) -> GLuint { + GLuint vbo = 0; + glGenBuffers(1, &vbo); + glBindBuffer(GL_ARRAY_BUFFER, vbo); + glBufferData(GL_ARRAY_BUFFER, std::size(data) * sizeof(block::glvert), + std::data(data), GL_STATIC_DRAW); + return vbo; + }; + const auto generate_vao = []() -> GLuint { + GLuint vao = 0; + glGenVertexArrays(1, &vao); + glBindVertexArray(vao); + // position + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, sizeof(glm::vec3) / sizeof(float), GL_FLOAT, + GL_FALSE, sizeof(block::glvert), nullptr); + // texture + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, sizeof(glm::vec3) / sizeof(float), GL_FLOAT, + GL_FALSE, sizeof(block::glvert), + reinterpret_cast<void*>(sizeof(glm::vec3))); + return vao; + }; + // If we were to emplace glo with these there is no guarantee that each + // function will be called in order (at least, for g++ it isn't). Therefore + // we need to call them in order first. + const auto solid_vbo = generate_vbo(solid_data); + const auto solid_vao = generate_vao(); + const auto water_vbo = generate_vbo(water_data); + const auto water_vao = generate_vao(); + this->glo.emplace(std::size(solid_data), solid_vbo, solid_vao, + std::size(water_data), water_vbo, water_vao); + return true; +} + +// http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-boxes/ +static bool box_in_frustum(const std::array<glm::vec3, 8>& points) noexcept { + const auto& frustum = client::render::camera::get_frustum(); + + for (const auto& plane : frustum) { + bool inside = false; + bool outside = false; + + for (const auto& point : points) { + const float distance = plane.x * point.x + plane.y * point.y + + plane.z * point.z + plane.w; + if (distance < 0.0f) { + outside = true; + } else { + inside = true; + } + + if (inside && outside) { + break; + } + } + + if (!inside) { + return false; + } + } + + return true; +}; + +static bool is_chunk_visible(const float world_x, + const float world_z) noexcept { + const std::array<glm::vec3, 8> box_vertices = + [&world_x, &world_z]() -> std::array<glm::vec3, 8> { + const float max_world_x = world_x + shared::world::chunk::WIDTH; + const float max_world_z = world_z + shared::world::chunk::WIDTH; + + return {glm::vec3{world_x, 0.0f, world_z}, + {max_world_x, 0.0f, world_z}, + {world_x, 0.0f, max_world_z}, + {max_world_x, 0.0f, max_world_z}, + {world_x, shared::world::chunk::HEIGHT, world_z}, + {max_world_x, shared::world::chunk::HEIGHT, world_z}, + {world_x, shared::world::chunk::HEIGHT, max_world_z}, + {max_world_x, shared::world::chunk::HEIGHT, max_world_z}}; + }(); + + return box_in_frustum(box_vertices); +} + +bool chunk::draw(const chunks_t& chunks, const shared::player& lp, + const pass& pass, const bool skip_regen) noexcept { + bool did_regen = false; + if (!this->glo.has_value() || this->should_regenerate_vbo) { + if (skip_regen || !maybe_regenerate_glo(chunks)) { + return false; + } + this->should_regenerate_vbo = false; + did_regen = true; + } + + const auto [world_x, world_z] = [&lp, this]() -> std::pair<float, float> { + const float offset_x = + static_cast<float>(this->pos.x - lp.get_chunk_pos().x); + const float offset_z = + static_cast<float>(this->pos.z - lp.get_chunk_pos().z); + return {offset_x * chunk::WIDTH, offset_z * chunk::WIDTH}; + }(); + + if (is_chunk_visible(world_x, world_z)) { + render(world_x, world_z, pass); + } + + return did_regen; +} + +} // namespace world +} // namespace client diff --git a/src/client/world.hh b/src/client/world/chunk.hh index 067f74c..5436525 100644 --- a/src/client/world.hh +++ b/src/client/world/chunk.hh @@ -1,5 +1,5 @@ -#ifndef CLIENT_WORLD_HH_ -#define CLIENT_WORLD_HH_ +#ifndef CLIENT_WORLD_CHUNK_HH_ +#define CLIENT_WORLD_CHUNK_HH_ #include <algorithm> #include <optional> @@ -9,19 +9,22 @@ #include "client/render/render.hh" #include "client/render/texture.hh" -#include "shared/player.hh" -#include "shared/world.hh" +#include "client/world/block.hh" +#include "shared/entity/player.hh" +#include "shared/world/chunk.hh" namespace client { namespace world { +class chunk; +using chunks_t = std::unordered_map<shared::math::coords, + std::optional<client::world::chunk>, + decltype(&shared::world::chunk::hash), + decltype(&shared::world::chunk::equal)>; + // client::world::chunk is a renderable shared::world::chunk. class chunk : public shared::world::chunk { public: - using map = std::unordered_map<shared::math::coords, - std::optional<client::world::chunk>, - decltype(&shared::world::chunk::hash), - decltype(&shared::world::chunk::equal)>; // Which part to draw when we call draw. enum class pass { solid, water }; @@ -53,35 +56,24 @@ private: std::optional<gl_objects> glo; private: - const chunk* get_neighbour(const chunk::map& chunks, + const chunk* get_neighbour(const chunks_t& chunks, shared::math::coords offset) const noexcept; - struct glface { - glm::vec3 vertice; - glm::vec3 texture; - }; - struct glface_args { - glm::vec3 translate; - float rotate_degrees; - glm::vec3 rotate_axis; - glm::vec3 texture_offset; - }; - static std::array<glface, 6> make_glfaces(const glface_args& args) noexcept; void render(const float x_offset, const float z_offset, const pass& pass) noexcept; - bool maybe_regenerate_glo(const chunk::map& chunks) noexcept; + bool maybe_regenerate_glo(const chunks_t& chunks) noexcept; public: template <typename... Args> chunk(Args&&... args) noexcept : shared::world::chunk(std::forward<Args>(args)...) {} + virtual ~chunk() noexcept = default; - void draw(const map& chunks, const shared::player& lp, - const pass& pass) noexcept; + // true if we regen'd, false otherwise + bool draw(const chunks_t& chunks, const shared::player& lp, + const pass& pass, const bool skip_regen = false) noexcept; - bool can_draw() const noexcept { - return this->glo.has_value(); - } + bool can_draw() const noexcept { return this->glo.has_value(); } }; } // namespace world diff --git a/src/client/world/world.dat b/src/client/world/world.dat Binary files differnew file mode 100644 index 0000000..e210d11 --- /dev/null +++ b/src/client/world/world.dat |