refactor(render): unify model and player rendering with single shader pipeline

src/render/model_renderer.cpp

@@ -18,14 +18,13 @@ void ModelRender::render_model(const std::string& name, const glm::vec3& pos,
 }
 
 void ModelRender::shadow_pass(const std::string& name, const glm::vec3& pos,
-                              const glm::mat4& light_matrix, Camera& camera) {
+                              Camera& camera) {
     auto& model_manager = m_renderer.model_manager();
     auto& root = model_manager.get_model(name);
     glm::mat4 transform = glm::translate(glm::mat4(1.0f), pos);
     auto& shader = m_renderer.get_shader("depth_model");
     glm::mat4 view = camera.get_camera_lookat();
 
-    shader.set_loc("lightSpaceMatrix", light_matrix);
     render_node(root, transform, view, shader, true);
 }
 
@@ -37,7 +36,10 @@ void ModelRender::render_node(const ModelNode& node, const glm::mat4& parent,
     if (shadow) {
         shader.set_loc("modelMatrix", transform);
     } else {
-        shader.set_loc("mv_matrix", view * transform);
+        glm::mat4 mv_matrix = view * transform;
+        shader.set_loc("modelMatrix", transform);
+        shader.set_loc("mv_matrix", mv_matrix);
+        shader.set_loc("norm_matrix", glm::transpose(glm::inverse(mv_matrix)));
     }
 
     for (auto& mesh : node.meshes) {
@@ -52,7 +54,7 @@ void ModelRender::render_node(const ModelNode& node, const glm::mat4& parent,
 void ModelRender::render_mesh(const Mesh& mesh, bool) {
     mesh.vao->bind();
     if (mesh.texture) {
-        mesh.texture->bind(0);
+        mesh.texture->bind(1);
     } else {
         Logger::error("Model Texture Not Find");
     }

src/render/player_renderer.cpp

@@ -302,15 +302,12 @@ void PlayerRenderer::render(const Shader& shader, ClientWorld& world) {
     }
 }
 
-void PlayerRenderer::shadow_render(const Shader& shader,
-                                   glm::mat4& light_matrix,
-                                   ClientWorld& world) {
+void PlayerRenderer::shadow_render(const Shader& shader, ClientWorld& world) {
     if (!m_inited) {
         Logger::error("Player Renderer isn't init");
         return;
     }
-    shader.use();
-    shader.set_loc("lightSpaceMatrix", light_matrix);
+
     auto& players = world.render_player_data();
 
     for (auto& player : players) {

src/render/shader_manager.cpp

@@ -29,8 +29,6 @@ void ShaderManager::init() {
                     "shaders/billboard_f_shader.glsl");
     register_shader("water", "shaders/water_v_shader.glsl",
                     "shaders/water_f_shader.glsl");
-    register_shader("player", "shaders/player_v_shader.glsl",
-                    "shaders/player_f_shader.glsl");
     register_shader("depth_model", "shaders/depth_model_vert.glsl",
                     "shaders/depth_model_frag.glsl");
     register_shader("rect", "shaders/rect_v_shader.glsl",

src/render/world_renderer.cpp

@@ -51,7 +51,6 @@ void WorldRenderer::render(ClientWorld& world) {
     render_world(world);
     render_outline(world);
     render_entity(world);
-    render_player(world);
 
     FrameBuffer::unbind();
 
@@ -291,31 +290,19 @@ void WorldRenderer::render_outline(ClientWorld& world) {
     }
 }
 
-void WorldRenderer::render_entity(ClientWorld& world) {
-    glEnable(GL_DEPTH_TEST);
-    auto& registry = world.get_registry();
-    auto view = registry.view<Transform, Model>();
-    auto& shader = m_renderer.get_shader("model_shader");
-    shader.use();
-    for (auto entity : view) {
-        auto [transform, model] = view.get<Transform, Model>(entity);
-        m_renderer.model_renderer().render_model(model.name, transform.pos,
-                                                 world.world_scene().camera());
-    }
-}
-
 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);
         m_renderer.model_renderer().shadow_pass(model.name, transform.pos,
-                                                light_matrix,
                                                 world.world_scene().camera());
     }
+    m_player_renderer.shadow_render(shader, world);
 }
 
 void WorldRenderer::shadow_map_generate(ClientWorld& world) {
@@ -422,10 +409,6 @@ void WorldRenderer::shadow_map_generate(ClientWorld& world) {
     }
 
     shadow_entity(world, light_space_matrix);
-
-    // player
-    auto& player_shadow = m_renderer.get_shader("depth_model");
-    m_player_renderer.shadow_render(player_shadow, light_space_matrix, world);
 }
 
 void WorldRenderer::render_underwater(ClientWorld& world) {
@@ -707,8 +690,8 @@ void WorldRenderer::render_transparent_block(const glm::mat4& mv_mat,
     glBindVertexArray(0);
 }
 
-void WorldRenderer::render_player(ClientWorld& world) {
-    auto& shader = m_renderer.get_shader("player");
+void WorldRenderer::render_entity(ClientWorld& world) {
+    auto& shader = m_renderer.get_shader("model_shader");
     shader.use();
     glm::vec3 light_dir_view =
         glm::normalize(glm::mat3(view_matrix) * m_parallel_light.lightdir);
@@ -729,6 +712,16 @@ void WorldRenderer::render_player(ClientWorld& world) {
     // shader.set_loc("skyColor", m_sky_uniform.sky_top);
 
     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) {
+        auto [transform, model] = view.get<Transform, Model>(entity);
+        m_renderer.model_renderer().render_model(model.name, transform.pos,
+                                                 world.world_scene().camera());
+    }
+
     m_player_renderer.render(shader, world);
 }