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

assets/shaders/model_frag.glsl

@@ -3,13 +3,45 @@
 in vec2 tc;
 in vec3 normal;
 in vec3 vert_pos;
-
+in vec4 FragPosLightSpace;
 out vec4 color;
 
-layout (binding = 0) uniform sampler2D samp;
+layout (binding = 0) uniform sampler2D shadowMap;
+layout (binding = 1) uniform sampler2D samp;
 
+uniform float ambientStrength;
+uniform vec3 sunlightColor;
+uniform vec3 ambientColor;
+uniform vec3 sunlightDir;
+uniform bool shader_on;
+uniform int shadowMode;
+uniform float lightSizeUV; 
+uniform float minRadius;
+uniform float maxRadius;
+
+#include "shadow.glsl"
 
 void main() {
-    color = texture(samp, tc);
+    vec4 objectColor = texture(samp, tc);
 
+    if (!shader_on) {
+        color = objectColor;
+        return;
+    }
+   
+    vec3 lightDir = normalize(-sunlightDir);
+    
+    vec3 norm = normalize(normal);
+
+    vec3 ambient = ambientStrength * ambientColor;
+    
+    float diff = max(dot(norm, lightDir), 0.0);
+    
+    vec3 diffuse = diff * sunlightColor;
+ 
+    float shadow = ShadowCalculation(FragPosLightSpace, norm, lightDir);  
+    //float shadow = 0.0;
+    //color = vec4(vec3(shadow),1);
+    //color = vec4(vec3(diff),1);
+    color = vec4((ambient + (1.0 - shadow) * (diffuse)) * objectColor.rgb, objectColor.a);
 }

assets/shaders/model_vert.glsl

@@ -6,17 +6,21 @@ layout (location = 2) in vec3 aNormal;
 
 uniform mat4 mv_matrix;
 uniform mat4 proj_matrix;
-
+uniform mat4 norm_matrix;
+uniform mat4 lightSpaceMatrix;
+uniform mat4 modelMatrix;
+out vec4 FragPosLightSpace;
 out vec3 normal;
 out vec2 tc;
 out vec3 vert_pos;
 
 
 void main() {
-    //vec4 worldPos = modelMatrix * vec4(pos, 1.0);
+    vec4 worldPos = modelMatrix * vec4(pos, 1.0);
+    FragPosLightSpace = lightSpaceMatrix * worldPos;
     vec4 viewPos = mv_matrix * vec4(pos, 1.0);
     tc = texCoord;
     vert_pos = pos;
-    //normal = normalize(mat3(norm_matrix) * aNormal);
+    normal = normalize(mat3(norm_matrix) * aNormal);
     gl_Position = proj_matrix * viewPos;
 }

assets/shaders/player_f_shader.glsl

@@ -1,47 +0,0 @@
-#version 460
-
-in vec2 tc;
-in vec3 normal;
-in vec3 vert_pos;
-in vec4 FragPosLightSpace;
-out vec4 color;
-
-layout (binding = 0) uniform sampler2D shadowMap;
-layout (binding = 1) uniform sampler2D samp;
-
-uniform float ambientStrength;
-uniform vec3 sunlightColor;
-uniform vec3 ambientColor;
-uniform vec3 sunlightDir;
-uniform bool shader_on;
-uniform int shadowMode;
-uniform float lightSizeUV; 
-uniform float minRadius;
-uniform float maxRadius;
-
-#include "shadow.glsl"
-
-void main() {
-    vec4 objectColor = texture(samp, tc);
-
-    if (!shader_on) {
-        color = objectColor;
-        return;
-    }
-   
-    vec3 lightDir = normalize(-sunlightDir);
-    
-    vec3 norm = normalize(normal);
-
-    vec3 ambient = ambientStrength * ambientColor;
-    
-    float diff = max(dot(norm, lightDir), 0.0);
-    
-    vec3 diffuse = diff * sunlightColor;
- 
-    float shadow = ShadowCalculation(FragPosLightSpace, norm, lightDir);  
-    //float shadow = 0.0;
-    //color = vec4(vec3(shadow),1);
-    //color = vec4(vec3(diff),1);
-    color = vec4((ambient + (1.0 - shadow) * (diffuse)) * objectColor.rgb, objectColor.a);
-}

assets/shaders/player_v_shader.glsl

@@ -1,27 +0,0 @@
-#version 460
-
-layout (location = 0) in vec3 pos;
-layout (location = 1) in vec2 texCoord;
-layout (location = 2) in vec3 aNormal;
-layout (location = 3) in vec3 aTangent;
-
-uniform mat4 mv_matrix;
-uniform mat4 proj_matrix;
-uniform mat4 norm_matrix;
-uniform mat4 lightSpaceMatrix;
-uniform mat4 modelMatrix;
-out vec4 FragPosLightSpace;
-out vec3 normal;
-out vec2 tc;
-out vec3 vert_pos;
-
-
-void main() {
-    vec4 worldPos = modelMatrix * vec4(pos, 1.0);
-    FragPosLightSpace = lightSpaceMatrix * worldPos;
-    vec4 viewPos = mv_matrix * vec4(pos, 1.0);
-    tc = texCoord;
-    vert_pos = pos;
-    normal = normalize(mat3(norm_matrix) * aNormal);
-    gl_Position = proj_matrix * viewPos;
-}

include/Cubed/render/model_renderer.hpp

@@ -14,7 +14,7 @@ public:
                       Camera& camera);
 
     void shadow_pass(const std::string& name, const glm::vec3& pos,
-                     const glm::mat4& light_matrix, Camera& camera);
+                     Camera& camera);
 
 private:
     Renderer& m_renderer;

include/Cubed/render/player_renderer.hpp

@@ -14,8 +14,7 @@ public:
     ~PlayerRenderer();
     void init();
     void render(const Shader& shader, ClientWorld& world);
-    void shadow_render(const Shader& shader, glm::mat4& light_matrix,
+    void shadow_render(const Shader& shader, ClientWorld& world);
-                       ClientWorld& world);
 
 private:
     struct PlayerVertex {

include/Cubed/render/world_renderer.hpp

@@ -132,9 +132,8 @@ private:
 
     void render_underwater(ClientWorld& world);
     void render_outline(ClientWorld& world);
-    void render_entity(ClientWorld& world);
     void shadow_entity(ClientWorld& world, const glm::mat4& light_matrix);
-    void render_player(ClientWorld& world);
+    void render_entity(ClientWorld& world);
 
     void render_normal_block(const glm::mat4& model_mat,
                              const glm::mat4& mv_mat, const glm::mat4& norm_mat,

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,
+void PlayerRenderer::shadow_render(const Shader& shader, ClientWorld& world) {
-                                   glm::mat4& light_matrix,
-                                   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) {
+void WorldRenderer::render_entity(ClientWorld& world) {
-    auto& shader = m_renderer.get_shader("player");
+    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);
 }