refactor(gameplay): replace entt components with SparseVector for player data

Refactor client world to use a custom SparseVector for player data instead of entt registry. Consolidate Transform, ViewAngles, and related structs into Position, Orientation, WalkPose. Introduce PlayerData and PlayerRenderData. Remove the unused move_system.cpp. Unify player render and shadow render into a single function.

include/Cubed/gameplay/client_world.hpp

@@ -8,10 +8,12 @@
 #include "Cubed/gameplay/client_player.hpp"
 #include "Cubed/gameplay/game_time.hpp"
 #include "Cubed/gameplay/network_client.hpp"
+#include "Cubed/gameplay/player_data.hpp"
 #include "Cubed/gameplay/world.hpp"
 #include "Cubed/input/event.hpp"
 #include "Cubed/tools/cubed_random.hpp"
 #include "Cubed/tools/priority_thread_pool.hpp"
+#include "Cubed/tools/sparse_vector.hpp"
 
 #include <absl/container/flat_hash_set.h>
 #include <deque>
@@ -20,15 +22,6 @@
 #include <tbb/concurrent_unordered_map.h>
 namespace Cubed {
 
-struct PlayerRenderData {
-    std::string name;
-    std::string uuid;
-    glm::vec3 render_pos;
-    float yaw;
-    float pitch;
-    Gait gait;
-    float angle;
-};
 class WorldScene;
 class ClientWorld : public World {
 public:
@@ -146,7 +139,10 @@ private:
     std::vector<glm::vec4> m_planes;
     std::jthread m_client_thread;
 
-    mutable std::shared_mutex m_registry_mutex;
+    mutable std::shared_mutex m_players_date_mutex;
+    using PlayerHandle = SparseVector<PlayerData>::Handle;
+    SparseVector<PlayerData> m_players_data;
+    std::unordered_map<std::string, PlayerHandle> m_players_handle;
 
     tbb::concurrent_queue<std::unique_ptr<ClientChunk>> m_pending_upload_queue;
     tbb::concurrent_queue<ChunkPos> m_dirty_chunk_queue;

include/Cubed/gameplay/entity.hpp

@@ -5,11 +5,18 @@
 #include <glm/glm.hpp>
 #include <string>
 namespace Cubed {
-struct Transform {
+
-    glm::vec3 pos{0, 0, 0};
+using ModelID = uint32_t;
-    glm::vec3 render_pos{0, 0, 0};
+
+struct Position {
+    glm::vec3 value{0.0f};
+};
+
+struct WalkPose {
     Gait gait = Gait::STOP;
+    // for arm roll caculate
     float walk_time = 0.0f;
+    // for sound play
     float moving_time = 0.0f;
 };
 
@@ -19,26 +26,22 @@ struct EntityInfo {
 };
 
 struct Model {
-    std::string name;
+    ModelID id;
 };
 
 struct Health {
-    float hp = 0;
+    float hp = 20;
     float max_hp = 20;
 };
 
-struct ViewAngles {
+struct Orientation {
-    float render_yaw = 0.0f;
     float yaw = 0.0f;
-    float render_pitch = 0.0f;
     float pitch = 0.0f;
-    float angle = 0.0f;
+    float roll = 0.0f;
 };
 
 struct Velocity {
-    float dx = 0.0f;
+    glm::vec3 value{0.0f};
-    float dy = 0.0f;
-    float dz = 0.0f;
 };
 
 struct HitBoxes {

include/Cubed/gameplay/player_data.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include "Cubed/gameplay/entity.hpp"
+namespace Cubed {
+struct PlayerData {
+    Position pos{};
+    Position render_pos{};
+    EntityInfo entity{};
+    WalkPose walk{};
+    Orientation angle{};
+    Orientation render_angle{};
+};
+
+struct PlayerRenderData {
+    EntityInfo info{};
+    Position render_pos{};
+    Orientation angle{};
+    Gait gait{};
+};
+
+} // namespace Cubed

include/Cubed/render/player_renderer.hpp

@@ -13,8 +13,7 @@ public:
     PlayerRenderer(Renderer& renderer);
     ~PlayerRenderer();
     void init();
-    void render(const Shader& shader, ClientWorld& world);
+    void render(const Shader& shader, ClientWorld& world, bool shadow_render);
-    void shadow_render(const Shader& shader, ClientWorld& world);
 
 private:
     struct PlayerVertex {

include/Cubed/tools/sparse_vector.hpp

@@ -0,0 +1,318 @@
+#pragma once
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <optional>
+#include <utility>
+#include <vector>
+namespace Cubed {
+template <typename T> class SparseVector {
+private:
+    std::vector<std::optional<T>> m_data;
+    std::vector<uint32_t> m_free_list;
+    std::vector<uint32_t> m_generation;
+
+    std::vector<uint32_t> m_dense;
+    std::vector<uint32_t> m_dense_index;
+
+public:
+    struct Handle {
+        uint32_t index;
+        uint32_t generation;
+
+        uint64_t value() const noexcept {
+            return (uint64_t(index) << 32) | generation;
+        }
+
+        bool operator==(const Handle&) const = default;
+
+        struct Hash {
+            size_t operator()(const Handle& h) const noexcept {
+                return h.value();
+            }
+        };
+    };
+
+    using value_type = T;
+    using reference = T&;
+    using const_reference = const T&;
+    using pointer = T*;
+
+    using size_type = size_t;
+
+    class iterator { // NOLINT
+    private:
+        SparseVector* m_owner;
+        size_t m_index;
+
+    public:
+        using iterator_category = std::random_access_iterator_tag;
+        using iterator_concept = std::random_access_iterator_tag;
+        using value_type = T;
+        using difference_type = std::ptrdiff_t;
+        using pointer = T*;
+        using reference = T&;
+
+        iterator(SparseVector* owner, size_t index)
+            : m_owner(owner), m_index(index) {}
+
+        reference operator*() {
+            return m_owner->m_data[m_owner->m_dense[m_index]].value();
+        }
+
+        pointer operator->() { return &(**this); }
+
+        iterator& operator++() {
+            ++m_index;
+            return *this;
+        }
+
+        iterator operator++(int) {
+            iterator tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        iterator& operator--() {
+            --m_index;
+            return *this;
+        }
+
+        iterator operator--(int) {
+            iterator tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        bool operator==(const iterator& other) const {
+            return m_owner == other.m_owner && m_index == other.m_index;
+        }
+
+        bool operator!=(const iterator& other) const {
+            return !(*this == other);
+        }
+
+        iterator operator+(difference_type n) const {
+            return iterator(m_owner, m_index + n);
+        }
+
+        iterator operator-(difference_type n) const {
+            return iterator(m_owner, m_index - n);
+        }
+
+        difference_type operator-(const iterator& other) const {
+            return static_cast<difference_type>(m_index) -
+                   static_cast<difference_type>(other.m_index);
+        }
+
+        iterator& operator+=(difference_type n) {
+            m_index += n;
+            return *this;
+        }
+
+        iterator& operator-=(difference_type n) {
+            m_index -= n;
+            return *this;
+        }
+
+        reference operator[](difference_type n) const { return *(*this + n); }
+
+        bool operator<(const iterator& other) const {
+            return m_index < other.m_index;
+        }
+
+        bool operator>(const iterator& other) const {
+            return m_index > other.m_index;
+        }
+
+        bool operator<=(const iterator& other) const {
+            return m_index <= other.m_index;
+        }
+
+        bool operator>=(const iterator& other) const {
+            return m_index >= other.m_index;
+        }
+        friend iterator operator+(difference_type n, const iterator& it) {
+            return it + n;
+        }
+    };
+
+    class const_iterator { // NOLINT
+    private:
+        const SparseVector* m_owner;
+        size_t m_index;
+
+    public:
+        using iterator_category = std::random_access_iterator_tag;
+        using iterator_concept = std::random_access_iterator_tag;
+        using value_type = T;
+        using difference_type = std::ptrdiff_t;
+        using pointer = const T*;
+        using reference = const T&;
+
+        const_iterator(const SparseVector* owner, size_t index)
+            : m_owner(owner), m_index(index) {}
+
+        reference operator*() const {
+            return m_owner->m_data[m_owner->m_dense[m_index]].value();
+        }
+
+        pointer operator->() const { return &(**this); }
+
+        const_iterator& operator++() {
+            ++m_index;
+            return *this;
+        }
+
+        const_iterator operator++(int) {
+            const_iterator tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        const_iterator& operator--() {
+            --m_index;
+            return *this;
+        }
+
+        const_iterator operator--(int) {
+            const_iterator tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        bool operator==(const const_iterator& other) const {
+            return m_owner == other.m_owner && m_index == other.m_index;
+        }
+
+        bool operator!=(const const_iterator& other) const {
+            return !(*this == other);
+        }
+
+        const_iterator operator+(difference_type n) const {
+            return const_iterator(m_owner, m_index + n);
+        }
+
+        const_iterator operator-(difference_type n) const {
+            return const_iterator(m_owner, m_index - n);
+        }
+
+        difference_type operator-(const const_iterator& other) const {
+            return static_cast<difference_type>(m_index) -
+                   static_cast<difference_type>(other.m_index);
+        }
+
+        const_iterator& operator+=(difference_type n) {
+            m_index += n;
+            return *this;
+        }
+
+        const_iterator& operator-=(difference_type n) {
+            m_index -= n;
+            return *this;
+        }
+
+        reference operator[](difference_type n) const { return *(*this + n); }
+
+        bool operator<(const const_iterator& other) const {
+            return m_index < other.m_index;
+        }
+
+        bool operator>(const const_iterator& other) const {
+            return m_index > other.m_index;
+        }
+
+        bool operator<=(const const_iterator& other) const {
+            return m_index <= other.m_index;
+        }
+
+        bool operator>=(const const_iterator& other) const {
+            return m_index >= other.m_index;
+        }
+        friend const_iterator operator+(difference_type n,
+                                        const const_iterator& it) {
+            return it + n;
+        }
+    };
+
+    template <class U> Handle insert(U&& value) {
+        uint32_t id;
+        if (!m_free_list.empty()) {
+            id = m_free_list.back();
+            m_free_list.pop_back();
+            m_data[id].emplace(std::forward<U>(value));
+
+            m_dense_index[id] = m_dense.size();
+        } else {
+            id = m_data.size();
+            m_data.push_back(std::forward<U>(value));
+            m_generation.push_back(1);
+            m_dense_index.emplace_back(m_dense.size());
+        }
+
+        m_dense.push_back(id);
+        return {id, m_generation[id]};
+    }
+
+    template <typename... Args> Handle emplace(Args&&... args) {
+        return insert(T(std::forward<Args>(args)...));
+    }
+
+    void erase(Handle h) {
+
+        if (!exists(h)) {
+            return;
+        }
+        uint32_t id = h.index;
+        m_free_list.push_back(id);
+        uint32_t index = m_dense_index[id];
+        uint32_t last_id = m_dense.back();
+        m_dense[index] = last_id;
+        m_dense_index[last_id] = index;
+
+        m_dense.pop_back();
+        m_data[id].reset();
+        ++m_generation[id];
+    }
+
+    T& operator[](Handle h) {
+        assert(exists(h));
+        return m_data[h.index].value();
+    }
+
+    const T& operator[](Handle h) const {
+        assert(exists(h));
+        return m_data[h.index].value();
+    }
+
+    bool exists(Handle h) const {
+        return h.index < m_generation.size() &&
+               m_generation[h.index] == h.generation;
+    }
+
+    void reserve(size_t n) {
+        m_data.reserve(n);
+        m_generation.reserve(n);
+        m_dense.reserve(n);
+        m_dense_index.reserve(n);
+    }
+
+    size_t size() const { return m_dense.size(); }
+
+    bool empty() const { return m_dense.empty(); }
+
+    iterator begin() { return iterator(this, 0); }
+
+    iterator end() { return iterator(this, m_dense.size()); }
+
+    const_iterator begin() const { return const_iterator(this, 0); }
+
+    const_iterator end() const { return const_iterator(this, m_dense.size()); }
+
+    const_iterator cbegin() const { return begin(); }
+
+    const_iterator cend() const { return end(); }
+};
+
+} // namespace Cubed

src/CMakeLists.txt

@@ -96,6 +96,5 @@ target_sources(${PROJECT_NAME}
         render/model_manager.cpp
         render/model_renderer.cpp
         gameplay/chunk.cpp
-        gameplay/move_system.cpp
         gameplay/hitbox_manager.cpp
 )

src/gameplay/client_world.cpp

@@ -295,13 +295,11 @@ void ClientWorld::report_block_change(const glm::ivec3& pos,
                                       unsigned id) const {
     if (id != 0) {
         AABB block_box = get_block_aabb(pos);
-        std::shared_lock lock(m_registry_mutex);
+        std::shared_lock lock(m_players_date_mutex);
 
-        for (auto& [key, player] : m_player_entities) {
+        for (const auto& player : m_players_data) {
-            auto [transform, entity_info] =
-                m_registry.get<Transform, EntityInfo>(player);
 
-            AABB box = ClientPlayer::get_aabb(transform.pos);
+            AABB box = ClientPlayer::get_aabb(player.pos.value);
             if (box.intersects(block_box)) {
                 return;
             }
@@ -333,22 +331,31 @@ void ClientWorld::receive_remote_player(const PlayerInfoRsp& rsp) {
     auto pitch = rsp.pitch();
     auto yaw = rsp.yaw();
     {
-        std::lock_guard lock(m_registry_mutex);
+        std::lock_guard lock(m_players_date_mutex);
         glm::vec3 pos{rsp.pos().x(), rsp.pos().y(), rsp.pos().z()};
-        auto it = m_player_entities.find(rsp.uuid());
+        auto it = m_players_handle.find(rsp.uuid());
-        if (it == m_player_entities.end()) {
+        if (it == m_players_handle.end()) {
-            auto entity =
+            PlayerData data{};
-                create_entity(EntityInfo{rsp.name(), rsp.uuid()},
+            data.entity.name = rsp.name();
-                              Transform{pos, pos, get_gait_from_id(rsp.gait())},
+            data.entity.uuid = rsp.uuid();
-                              ViewAngles{yaw, yaw, pitch, pitch});
+            data.angle.pitch = pitch;
-            m_player_entities.try_emplace(rsp.uuid(), entity);
+            data.angle.yaw = yaw;
+            data.render_angle.pitch = pitch;
+            data.render_angle.yaw = yaw;
+            data.pos.value = pos;
+            data.render_pos.value = pos;
+            data.walk.gait = get_gait_from_id(rsp.gait());
+            auto handle = m_players_data.emplace(std::move(data));
+            m_players_handle.try_emplace(rsp.uuid(), handle);
         } else {
-            auto& transform = m_registry.get<Transform>(it->second);
+            auto it = m_players_handle.find(rsp.uuid());
-            transform.pos = pos;
+            if (it != m_players_handle.end()) {
-            transform.gait = get_gait_from_id(rsp.gait());
+                auto& data = m_players_data[it->second];
-            auto& view_angles = m_registry.get<ViewAngles>(it->second);
+                data.pos.value = pos;
-            view_angles.yaw = yaw;
+                data.walk.gait = get_gait_from_id(rsp.gait());
-            view_angles.pitch = pitch;
+                data.angle.yaw = yaw;
+                data.angle.pitch = pitch;
+            }
         }
         // Logger::info("Player {} pos Update", rsp.name());
     }
@@ -364,13 +371,13 @@ void ClientWorld::receive_player_logout(const LogoutRsp& rsp) {
         return;
     }
     {
-        std::lock_guard lock(m_registry_mutex);
+        std::lock_guard lock(m_players_date_mutex);
-        auto it = m_player_entities.find(rsp.uuid());
+        auto it = m_players_handle.find(rsp.uuid());
-        if (it == m_player_entities.end()) {
+        if (it == m_players_handle.end()) {
             Logger::warn("Player {} not find", rsp.uuid());
         } else {
-            m_registry.destroy(it->second);
+            m_players_data.erase(it->second);
-            m_player_entities.erase(rsp.uuid());
+            m_players_handle.erase(it);
             Logger::info("Player {} erase", rsp.uuid());
         }
     }
@@ -480,8 +487,6 @@ void ClientWorld::init(std::string_view player_name,
     Logger::info("Send Login Request");
     m_client->send(make_packet(req), 0);
     m_audio.play_bgm();
-    create_entity(Transform{glm::vec3{0.0f, 100.0f, 0.0f}},
-                  Model{"model/creature/pig.glb"});
 }
 
 void ClientWorld::receive_login_rsp(LoginRsp& rsp) {
@@ -876,43 +881,43 @@ void ClientWorld::update(float delta_time) {
 
 void ClientWorld::update_players(float dt) {
 
-    auto update_renderinfo = [this, dt](entt::entity player) {
+    auto update_renderinfo = [this, dt](PlayerData& player) {
-        auto& transform = m_registry.get<Transform>(player);
+        player.render_pos.value =
-        transform.render_pos =
+            glm::mix(player.render_pos.value, player.pos.value, 0.15f);
-            glm::mix(transform.render_pos, transform.pos, 0.15f);
+        if (Math::distance2(player.render_pos.value,
-        if (Math::distance2(transform.render_pos, m_player.get_player_pos()) >
+                            m_player.get_player_pos()) >
             m_rendering_distance * CHUNK_SIZE * m_rendering_distance *
                 CHUNK_SIZE) {
             return;
         }
-        auto& view_angles = m_registry.get<ViewAngles>(player);
+        player.render_angle.yaw =
-        view_angles.render_yaw =
+            glm::mix(player.render_angle.yaw, player.angle.yaw, 0.15);
-            glm::mix(view_angles.render_yaw, view_angles.yaw, 0.15);
+        player.render_angle.pitch =
-        view_angles.render_pitch =
+            glm::mix(player.render_angle.pitch, player.angle.pitch, 0.15);
-            glm::mix(view_angles.render_pitch, view_angles.pitch, 0.15);
 
-        if (transform.gait == Gait::WALK || transform.gait == Gait::RUN) {
+        if (player.walk.gait == Gait::WALK || player.walk.gait == Gait::RUN) {
 
-            transform.walk_time += dt;
+            player.walk.walk_time += dt;
 
-            float speed = transform.gait == Gait::RUN ? 14.0f : 8.0f;
+            float speed = player.walk.gait == Gait::RUN ? 14.0f : 8.0f;
-            float amp = transform.gait == Gait::RUN ? 50.0f : 35.0f;
+            float amp = player.walk.gait == Gait::RUN ? 50.0f : 35.0f;
             // float amp = 90.0f;
-            view_angles.angle =
+            player.render_angle.roll =
-                glm::sin(transform.walk_time * speed) * glm::radians(amp);
+                glm::sin(player.walk.walk_time * speed) * glm::radians(amp);
-        } else if (transform.gait == Gait::STOP) {
+        } else if (player.walk.gait == Gait::STOP) {
             float t = glm::clamp(dt * 10.0f, 0.0f, 1.0f);
-            view_angles.angle = glm::mix(view_angles.angle, 0.0f, t);
+            player.render_angle.roll =
+                glm::mix(player.render_angle.roll, 0.0f, t);
         }
 
         // walking sound
-        if (transform.gait == Gait::STOP) {
+        if (player.walk.gait == Gait::STOP) {
-            transform.moving_time = 0.0f;
+            player.walk.moving_time = 0.0f;
         } else {
-            transform.moving_time += dt;
+            player.walk.moving_time += dt;
         }
         auto play_walk_sound = [&]() {
-            glm::ivec3 block = glm::floor(transform.render_pos);
+            glm::ivec3 block = glm::floor(player.render_pos.value);
             block.y -= 1;
             BlockType id = get_block_tpye(block);
             if (id == 0) {
@@ -920,31 +925,32 @@ void ClientWorld::update_players(float dt) {
             }
             std::string name = BlockManager::name_form_id(id);
             std::string sound = "block/" + name + "/walk.ogg";
-            m_audio.play_3d(sound, transform.render_pos);
+            m_audio.play_3d(sound, player.render_pos.value);
         };
-        if (transform.gait == Gait::WALK) {
+        if (player.walk.gait == Gait::WALK) {
-            if (transform.moving_time >= ClientPlayer::WALK_SOUND_INTERVAL) {
+            if (player.walk.moving_time >= ClientPlayer::WALK_SOUND_INTERVAL) {
-                transform.moving_time = 0.0f;
+                player.walk.moving_time = 0.0f;
                 play_walk_sound();
             }
         }
-        if (transform.gait == Gait::RUN) {
+        if (player.walk.gait == Gait::RUN) {
-            if (transform.moving_time >= ClientPlayer::RUN_SOUND_INTERVAL) {
+            if (player.walk.moving_time >= ClientPlayer::RUN_SOUND_INTERVAL) {
-                transform.moving_time = 0.0f;
+                player.walk.moving_time = 0.0f;
                 play_walk_sound();
             }
         }
-        auto& player_info = m_registry.get<EntityInfo>(player);
+        PlayerRenderData render_data;
-        m_render_player_data.emplace_back(
+        render_data.render_pos = player.render_pos;
-            player_info.name, player_info.uuid, transform.render_pos,
+        render_data.angle = player.render_angle;
-            view_angles.render_yaw, view_angles.render_pitch, transform.gait,
+        render_data.gait = player.walk.gait;
-            view_angles.angle);
+        render_data.info = player.entity;
+        m_render_player_data.emplace_back(std::move(render_data));
     };
 
     {
-        std::lock_guard lock(m_registry_mutex);
+        std::lock_guard lock(m_players_date_mutex);
 
-        for (auto& [_, player] : m_player_entities) {
+        for (auto& player : m_players_data) {
             update_renderinfo(player);
         }
         {
@@ -963,11 +969,15 @@ void ClientWorld::update_players(float dt) {
                 float t = glm::clamp(dt * 10.0f, 0.0f, 1.0f);
                 angle = glm::mix(angle, 0.0f, t);
             }
-
+            PlayerRenderData render_data{};
-            m_render_player_data.emplace_back(
+            render_data.render_pos.value = m_player.get_player_pos();
-                m_player.get_name(), m_player.get_uuid(),
+            render_data.angle.yaw = m_player.yaw();
-                m_player.get_player_pos(), m_player.yaw(), m_player.pitch(),
+            render_data.angle.pitch = m_player.pitch();
-                m_player.get_gait(), m_player.angle());
+            render_data.angle.roll = angle;
+            render_data.gait = m_player.get_gait();
+            render_data.info.name = m_player.get_name();
+            render_data.info.uuid = m_player.get_uuid();
+            m_render_player_data.emplace_back(std::move(render_data));
         }
     }
 }

src/render/player_renderer.cpp

@@ -189,7 +189,8 @@ void PlayerRenderer::init() {
     m_inited = true;
 }
 
-void PlayerRenderer::render(const Shader& shader, ClientWorld& world) {
+void PlayerRenderer::render(const Shader& shader, ClientWorld& world,
+                            bool shadow_render) {
     if (!m_inited) {
         Logger::error("Player Renderer isn't init");
         return;
@@ -205,7 +206,7 @@ void PlayerRenderer::render(const Shader& shader, ClientWorld& world) {
 
     for (auto& player : players) {
 
-        if (player.uuid == m_player.get_uuid()) {
+        if (player.info.uuid == m_player.get_uuid()) {
             if (camera.is_first_person()) {
                 continue;
             }
@@ -213,14 +214,14 @@ void PlayerRenderer::render(const Shader& shader, ClientWorld& world) {
 
         glm::mat4 model(1.0f);
 
-        model = glm::translate(model, player.render_pos);
+        model = glm::translate(model, player.render_pos.value);
 
         // model = glm::translate(model, glm::vec3(0.5f, 0.0f, 0.5f));
         // glm::rotate(..., +yaw, Y) follows the OpenGL right‑handed coordinate
         // system, where a positive angle means counter‑clockwise rotation.
         // Therefore the model must use -yaw to align with the direction of
         // m_front.
-        model = glm::rotate(model, glm::radians(-player.yaw + 180.0f),
+        model = glm::rotate(model, glm::radians(-player.angle.yaw + 180.0f),
                             glm::vec3(0, 1, 0));
         model = glm::translate(model, glm::vec3(-0.5f, 0.0f, -0.5f));
 
@@ -234,99 +235,16 @@ void PlayerRenderer::render(const Shader& shader, ClientWorld& world) {
             return mat;
         };
 
-        for (int i = 0; i < BODY_PART_NUM; i++) {
+        auto set_loc = [&](glm::mat4& model_matrix) {
-            switch (i) {
+            if (!shadow_render) {
-            case 0: {
+                glm::mat4 model_view = m_v_mat * model_matrix;
-                glm::mat4 head_model = model;
-                head_model = glm::translate(head_model, HEAD_PIVOT);
-                head_model =
-                    glm::rotate(head_model, glm::radians(-player.pitch),
-                                glm::vec3(1, 0, 0));
-                head_model = glm::translate(head_model, -HEAD_PIVOT);
-                glm::mat4 head_mv = m_v_mat * head_model;
-                shader.set_loc("norm_matrix",
-                               glm::transpose(glm::inverse(head_mv)));
-                shader.set_loc("modelMatrix", head_model);
-                shader.set_loc("mv_matrix", head_mv);
-            } break;
-            case 1: {
-                glm::mat4 mv_mat = m_v_mat * model;
-                shader.set_loc("norm_matrix",
-                               glm::transpose(glm::inverse(mv_mat)));
-                shader.set_loc("modelMatrix", model);
-                shader.set_loc("mv_matrix", mv_mat);
-            } break;
-            case 2: { // left arm
-                glm::mat4 model_mat =
-                    make_rotated(LEFT_ARM_PIVOT, player.angle);
-                glm::mat4 mv_mat = m_v_mat * model_mat;
-                shader.set_loc("norm_matrix",
-                               glm::transpose(glm::inverse(mv_mat)));
-                shader.set_loc("modelMatrix", model_mat);
-                shader.set_loc("mv_matrix", mv_mat);
-            } break;
-            case 3: { // right arm
-                glm::mat4 model_mat =
-                    make_rotated(RIGHT_ARM_PIVOT, -player.angle);
-                glm::mat4 mv_mat = m_v_mat * model_mat;
-                shader.set_loc("norm_matrix",
-                               glm::transpose(glm::inverse(mv_mat)));
-                shader.set_loc("modelMatrix", model_mat);
-                shader.set_loc("mv_matrix", mv_mat);
-            } break;
-            case 4: { // left leg
-                glm::mat4 model_mat =
-                    make_rotated(LEFT_LEG_PIVOT, -player.angle);
-                glm::mat4 mv_mat = m_v_mat * model_mat;
-                shader.set_loc("norm_matrix",
-                               glm::transpose(glm::inverse(mv_mat)));
-                shader.set_loc("modelMatrix", model_mat);
-                shader.set_loc("mv_matrix", mv_mat);
-            } break;
-            case 5: { // right leg
-                glm::mat4 model_mat =
-                    make_rotated(RIGHT_LEG_PIVOT, player.angle);
 
-                glm::mat4 mv_mat = m_v_mat * model_mat;
                 shader.set_loc("norm_matrix",
-                               glm::transpose(glm::inverse(mv_mat)));
+                               glm::transpose(glm::inverse(model_view)));
-                shader.set_loc("modelMatrix", model_mat);
+                shader.set_loc("mv_matrix", model_view);
-                shader.set_loc("mv_matrix", mv_mat);
-            } break;
             }
 
-            glBindVertexArray(m_vao[i]);
+            shader.set_loc("modelMatrix", model_matrix);
-            glEnable(GL_DEPTH_TEST);
-            glDrawArrays(GL_TRIANGLES, 0, m_vertices[i].size());
-        }
-    }
-}
-
-void PlayerRenderer::shadow_render(const Shader& shader, ClientWorld& world) {
-    if (!m_inited) {
-        Logger::error("Player Renderer isn't init");
-        return;
-    }
-
-    auto& players = world.render_player_data();
-
-    for (auto& player : players) {
-        glm::mat4 model(1.0f);
-
-        model = glm::translate(model, player.render_pos);
-
-        // model = glm::translate(model, glm::vec3(0.5f, 0.0f, 0.5f));
-
-        model = glm::rotate(model, glm::radians(-player.yaw + 180.0f),
-                            glm::vec3(0, 1, 0));
-        model = glm::translate(model, glm::vec3(-0.5f, 0.0f, -0.5f));
-
-        auto make_rotated = [&](glm::vec3 pivot, float angle) {
-            glm::mat4 mat = model;
-            mat = glm::translate(mat, pivot);
-            mat = glm::rotate(mat, angle, glm::vec3(1, 0, 0));
-            mat = glm::translate(mat, -pivot);
-            return mat;
         };
 
         for (int i = 0; i < BODY_PART_NUM; i++) {
@@ -335,33 +253,37 @@ void PlayerRenderer::shadow_render(const Shader& shader, ClientWorld& world) {
                 glm::mat4 head_model = model;
                 head_model = glm::translate(head_model, HEAD_PIVOT);
                 head_model =
-                    glm::rotate(head_model, glm::radians(-player.pitch),
+                    glm::rotate(head_model, glm::radians(-player.angle.pitch),
                                 glm::vec3(1, 0, 0));
                 head_model = glm::translate(head_model, -HEAD_PIVOT);
-                shader.set_loc("modelMatrix", head_model);
+                set_loc(head_model);
             } break;
             case 1: {
-                shader.set_loc("modelMatrix", model);
+                set_loc(model);
             } break;
             case 2: { // left arm
-                shader.set_loc("modelMatrix",
+                glm::mat4 matrix =
-                               make_rotated(LEFT_ARM_PIVOT, player.angle));
+                    make_rotated(LEFT_ARM_PIVOT, player.angle.roll);
+                set_loc(matrix);
             } break;
             case 3: { // right arm
-                shader.set_loc("modelMatrix",
+                glm::mat4 matrix =
-                               make_rotated(RIGHT_ARM_PIVOT, -player.angle));
+                    make_rotated(RIGHT_ARM_PIVOT, -player.angle.roll);
+                set_loc(matrix);
             } break;
             case 4: { // left leg
-                shader.set_loc("modelMatrix",
+                glm::mat4 matrix =
-
+                    make_rotated(LEFT_LEG_PIVOT, -player.angle.roll);
-                               make_rotated(LEFT_LEG_PIVOT, -player.angle));
+                set_loc(matrix);
             } break;
             case 5: { // right leg
-                shader.set_loc("modelMatrix",
+                glm::mat4 matrix =
+                    make_rotated(RIGHT_LEG_PIVOT, player.angle.roll);
 
-                               make_rotated(RIGHT_LEG_PIVOT, player.angle));
+                set_loc(matrix);
             } break;
             }
+
             glBindVertexArray(m_vao[i]);
             glEnable(GL_DEPTH_TEST);
             glDrawArrays(GL_TRIANGLES, 0, m_vertices[i].size());

src/render/world_renderer.cpp

@@ -3,7 +3,6 @@
 #include "Cubed/camera.hpp"
 #include "Cubed/debug_collector.hpp"
 #include "Cubed/gameplay/client_world.hpp"
-#include "Cubed/gameplay/entity.hpp"
 #include "Cubed/render/renderer.hpp"
 #include "Cubed/render/renderer_constants.hpp"
 #include "Cubed/scene/world_scene.hpp"
@@ -292,17 +291,18 @@ void WorldRenderer::render_outline(ClientWorld& world) {
 
 void WorldRenderer::shadow_entity(ClientWorld& world,
                                   const glm::mat4& light_matrix) {
-    auto& registry = world.get_registry();
-    auto view = registry.view<Transform, Model>();
     auto& shader = m_renderer.get_shader("depth_model");
     shader.use();
     shader.set_loc("lightSpaceMatrix", light_matrix);
-    for (auto entity : view) {
+    /*
-        auto [transform, model] = view.get<Transform, Model>(entity);
+     auto& registry = world.get_registry();
-        m_renderer.model_renderer().shadow_pass(model.name, transform.pos,
+auto view = registry.view<Transform, Model>();
+for (auto entity : view) {
+auto [transform, model] = view.get<Transform, Model>(entity);
+m_renderer.model_renderer().shadow_pass(model.name, transform.pos,
                 world.world_scene().camera());
-    }
+}*/
-    m_player_renderer.shadow_render(shader, world);
+    m_player_renderer.render(shader, world, true);
 }
 
 void WorldRenderer::shadow_map_generate(ClientWorld& world) {
@@ -714,6 +714,7 @@ void WorldRenderer::render_entity(ClientWorld& world) {
     m_depth_map_texture->bind(0);
 
     glEnable(GL_DEPTH_TEST);
+    /*
         auto& registry = world.get_registry();
     auto view = registry.view<Transform, Model>();
     for (auto entity : view) {
@@ -721,8 +722,9 @@ void WorldRenderer::render_entity(ClientWorld& world) {
         m_renderer.model_renderer().render_model(model.name, transform.pos,
                                                  world.world_scene().camera());
     }
+    */
 
-    m_player_renderer.render(shader, world);
+    m_player_renderer.render(shader, world, false);
 }
 
 glm::vec3 WorldRenderer::quantize_sun_direction(const glm::vec3& lightdir,