zhenyan121/Cubed
1
0
Fork 0
mirror of https://github.com/zhenyan121/Cubed.git synced 2026-08-08 17:57:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
zhenyan121
2026-07-25 13:29:52 +08:00
parent 2e3b4f4f0f
commit 2568eb7d18
11 changed files with 67 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
assets/shaders/model_frag.glsl
View File

@@ -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);
}

10
assets/shaders/model_vert.glsl
View File

@@ -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;
}

47
assets/shaders/player_f_shader.glsl
View File

@@ -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);
}

27
assets/shaders/player_v_shader.glsl
View File

@@ -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;
}

2
include/Cubed/render/model_renderer.hpp
View File

@@ -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;

3
include/Cubed/render/player_renderer.hpp
View File

@@ -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,
ClientWorld& world);
void shadow_render(const Shader& shader, ClientWorld& world);
private:
struct PlayerVertex {

3
include/Cubed/render/world_renderer.hpp
View File

@@ -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,

10
src/render/model_renderer.cpp
View File

@@ -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");
}

7
src/render/player_renderer.cpp
View File

@@ -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) {

2
src/render/shader_manager.cpp
View File

@@ -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",

35
src/render/world_renderer.cpp
View File

@@ -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);
}