RiCoCoSoul
/
Extra2D
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor(renderer): 清理代码并优化结构 

- 移除renderer_module.cpp中注释掉的代码
- 重新组织director.cpp的代码格式和结构
- 简化shader.cpp的日志输出和代码格式
- 添加glad头文件包含
This commit is contained in:
ChestnutYueyue 2026-03-02 04:57:44 +08:00
parent 92be7d9d18
commit 3b827149ba
3 changed files with 273 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/renderer/renderer_module.cpp
View File

@ -1,3 +1,4 @@
#include "glad/glad.h"
#include <algorithm>
#include <event/events.h>
#include <glm/gtc/type_ptr.hpp>
@ -142,9 +143,6 @@ void RendererModule::onWindowShow() {
setViewport(0, 0, static_cast<int32>(windowWidth),
static_cast<int32>(windowHeight));
// 禁用深度测试和背面剔除（2D渲染不需要）
// glDisable(GL_DEPTH_TEST);
// glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

378
src/renderer/shader.cpp
View File

@ -1,236 +1,226 @@
#include <renderer/shader.h>
#include <utils/logger.h>
#include <glad/glad.h>
#include <fstream>
#include <glad/glad.h>
#include <renderer/shader.h>
#include <sstream>
#include <utils/logger.h>
namespace extra2d {
Shader::Shader() = default;
Shader::~Shader() {
if (program_ != 0) {
glDeleteProgram(program_);
program_ = 0;
}
if (program_ != 0) {
glDeleteProgram(program_);
program_ = 0;
}
}
bool Shader::loadFromFile(const std::string& vsPath, const std::string& fsPath) {
// 读取顶点着色器
std::ifstream vsFile(vsPath);
if (!vsFile.is_open()) {
E2D_LOG_ERROR("Failed to open vertex shader: {}", vsPath);
return false;
}
std::stringstream vsStream;
vsStream << vsFile.rdbuf();
std::string vsSource = vsStream.str();
// 读取片段着色器
std::ifstream fsFile(fsPath);
if (!fsFile.is_open()) {
E2D_LOG_ERROR("Failed to open fragment shader: {}", fsPath);
return false;
}
std::stringstream fsStream;
fsStream << fsFile.rdbuf();
std::string fsSource = fsStream.str();
return loadFromSource(vsSource, fsSource);
bool Shader::loadFromFile(const std::string &vsPath,
const std::string &fsPath) {
// 读取顶点着色器
std::ifstream vsFile(vsPath);
if (!vsFile.is_open()) {
E2D_LOG_ERROR("Failed to open vertex shader: {}", vsPath);
return false;
}
std::stringstream vsStream;
vsStream << vsFile.rdbuf();
std::string vsSource = vsStream.str();
// 读取片段着色器
std::ifstream fsFile(fsPath);
if (!fsFile.is_open()) {
E2D_LOG_ERROR("Failed to open fragment shader: {}", fsPath);
return false;
}
std::stringstream fsStream;
fsStream << fsFile.rdbuf();
std::string fsSource = fsStream.str();
return loadFromSource(vsSource, fsSource);
}
bool Shader::loadFromSource(const std::string& vsSource, const std::string& fsSource) {
// 删除旧程序
if (program_ != 0) {
glDeleteProgram(program_);
program_ = 0;
}
uniformCache_.clear();
// 处理源码（添加版本声明）
std::string processedVS = addVersionIfNeeded(vsSource, GL_VERTEX_SHADER);
std::string processedFS = addVersionIfNeeded(fsSource, GL_FRAGMENT_SHADER);
E2D_LOG_INFO("Compiling vertex shader...");
// 编译顶点着色器
GLuint vs = compileShader(GL_VERTEX_SHADER, processedVS);
if (vs == 0) {
E2D_LOG_ERROR("Vertex shader compilation failed");
return false;
}
E2D_LOG_INFO("Compiling fragment shader...");
// 编译片段着色器
GLuint fs = compileShader(GL_FRAGMENT_SHADER, processedFS);
if (fs == 0) {
E2D_LOG_ERROR("Fragment shader compilation failed");
glDeleteShader(vs);
return false;
}
E2D_LOG_INFO("Linking shader program...");
// 链接程序
if (!linkProgram(vs, fs)) {
E2D_LOG_ERROR("Shader program linking failed");
glDeleteShader(vs);
glDeleteShader(fs);
return false;
}
// 清理着色器对象
bool Shader::loadFromSource(const std::string &vsSource,
const std::string &fsSource) {
// 删除旧程序
if (program_ != 0) {
glDeleteProgram(program_);
program_ = 0;
}
uniformCache_.clear();
// 处理源码（添加版本声明）
std::string processedVS = addVersionIfNeeded(vsSource, GL_VERTEX_SHADER);
std::string processedFS = addVersionIfNeeded(fsSource, GL_FRAGMENT_SHADER);
E2D_LOG_INFO("Compiling vertex shader...");
// 编译顶点着色器
GLuint vs = compileShader(GL_VERTEX_SHADER, processedVS);
if (vs == 0) {
E2D_LOG_ERROR("Vertex shader compilation failed");
return false;
}
E2D_LOG_INFO("Compiling fragment shader...");
// 编译片段着色器
GLuint fs = compileShader(GL_FRAGMENT_SHADER, processedFS);
if (fs == 0) {
E2D_LOG_ERROR("Fragment shader compilation failed");
glDeleteShader(vs);
return false;
}
E2D_LOG_INFO("Linking shader program...");
// 链接程序
if (!linkProgram(vs, fs)) {
E2D_LOG_ERROR("Shader program linking failed");
glDeleteShader(vs);
glDeleteShader(fs);
E2D_LOG_INFO("Shader program created successfully, program ID: {}", program_);
return true;
return false;
}
// 清理着色器对象
glDeleteShader(vs);
glDeleteShader(fs);
E2D_LOG_INFO("Shader program created successfully, program ID: {}", program_);
return true;
}
void Shader::bind() const {
if (program_ != 0) {
glUseProgram(program_);
}
if (program_ != 0) {
glUseProgram(program_);
}
}
void Shader::unbind() const {
glUseProgram(0);
void Shader::unbind() const { glUseProgram(0); }
void Shader::setUniformBlock(const std::string &name, uint32_t binding) {
if (program_ == 0)
return;
GLuint index = glGetUniformBlockIndex(program_, name.c_str());
if (index != GL_INVALID_INDEX) {
glUniformBlockBinding(program_, index, binding);
}
}
void Shader::setUniformBlock(const std::string& name, uint32_t binding) {
if (program_ == 0) return;
GLuint index = glGetUniformBlockIndex(program_, name.c_str());
if (index != GL_INVALID_INDEX) {
glUniformBlockBinding(program_, index, binding);
}
void Shader::setInt(const std::string &name, int value) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform1i(location, value);
}
}
void Shader::setInt(const std::string& name, int value) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform1i(location, value);
}
void Shader::setFloat(const std::string &name, float value) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform1f(location, value);
}
}
void Shader::setFloat(const std::string& name, float value) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform1f(location, value);
}
void Shader::setVec2(const std::string &name, float x, float y) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform2f(location, x, y);
}
}
void Shader::setVec2(const std::string& name, float x, float y) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform2f(location, x, y);
}
void Shader::setVec4(const std::string &name, float x, float y, float z,
float w) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform4f(location, x, y, z, w);
}
}
void Shader::setVec4(const std::string& name, float x, float y, float z, float w) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniform4f(location, x, y, z, w);
}
void Shader::setMat4(const std::string &name, const float *value) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniformMatrix4fv(location, 1, GL_FALSE, value);
}
}
void Shader::setMat4(const std::string& name, const float* value) {
GLint location = getUniformLocation(name);
if (location != -1) {
glUniformMatrix4fv(location, 1, GL_FALSE, value);
// 调试：输出设置成功的uniform
static int logCount = 0;
if (logCount < 3) {
E2D_LOG_INFO("Set uniform '{}' at location {}", name, location);
logCount++;
}
} else {
// 调试：输出未找到的uniform
static bool loggedOnce = false;
if (!loggedOnce) {
E2D_LOG_WARN("Uniform '{}' not found in shader", name);
loggedOnce = true;
}
}
}
GLuint Shader::compileShader(GLenum type, const std::string &source) {
GLuint shader = glCreateShader(type);
GLuint Shader::compileShader(GLenum type, const std::string& source) {
GLuint shader = glCreateShader(type);
const char* src = source.c_str();
glShaderSource(shader, 1, &src, nullptr);
glCompileShader(shader);
// 检查编译状态
GLint success;
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success) {
char infoLog[512];
glGetShaderInfoLog(shader, 512, nullptr, infoLog);
const char* typeStr = (type == GL_VERTEX_SHADER) ? "vertex" : "fragment";
E2D_LOG_ERROR("{} shader compilation failed: {}", typeStr, infoLog);
glDeleteShader(shader);
return 0;
}
return shader;
const char *src = source.c_str();
glShaderSource(shader, 1, &src, nullptr);
glCompileShader(shader);
// 检查编译状态
GLint success;
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success) {
char infoLog[512];
glGetShaderInfoLog(shader, 512, nullptr, infoLog);
const char *typeStr = (type == GL_VERTEX_SHADER) ? "vertex" : "fragment";
E2D_LOG_ERROR("{} shader compilation failed: {}", typeStr, infoLog);
glDeleteShader(shader);
return 0;
}
return shader;
}
bool Shader::linkProgram(GLuint vertexShader, GLuint fragmentShader) {
program_ = glCreateProgram();
glAttachShader(program_, vertexShader);
glAttachShader(program_, fragmentShader);
glLinkProgram(program_);
// 检查链接状态
GLint success;
glGetProgramiv(program_, GL_LINK_STATUS, &success);
if (!success) {
char infoLog[512];
glGetProgramInfoLog(program_, 512, nullptr, infoLog);
E2D_LOG_ERROR("Shader program linking failed: {}", infoLog);
glDeleteProgram(program_);
program_ = 0;
return false;
}
return true;
program_ = glCreateProgram();
glAttachShader(program_, vertexShader);
glAttachShader(program_, fragmentShader);
glLinkProgram(program_);
// 检查链接状态
GLint success;
glGetProgramiv(program_, GL_LINK_STATUS, &success);
if (!success) {
char infoLog[512];
glGetProgramInfoLog(program_, 512, nullptr, infoLog);
E2D_LOG_ERROR("Shader program linking failed: {}", infoLog);
glDeleteProgram(program_);
program_ = 0;
return false;
}
return true;
}
GLint Shader::getUniformLocation(const std::string& name) {
if (program_ == 0) return -1;
// 检查缓存
auto it = uniformCache_.find(name);
if (it != uniformCache_.end()) {
return it->second;
}
// 查询 uniform 位置
GLint location = glGetUniformLocation(program_, name.c_str());
uniformCache_[name] = location;
return location;
GLint Shader::getUniformLocation(const std::string &name) {
if (program_ == 0)
return -1;
// 检查缓存
auto it = uniformCache_.find(name);
if (it != uniformCache_.end()) {
return it->second;
}
// 查询 uniform 位置
GLint location = glGetUniformLocation(program_, name.c_str());
uniformCache_[name] = location;
return location;
}
std::string Shader::addVersionIfNeeded(const std::string& source, GLenum type) {
// 如果已经包含版本声明，直接返回
if (source.find("#version") != std::string::npos) {
return source;
}
// 添加 OpenGL ES 3.2 版本声明
std::string result = "#version 320 es\n";
// 片段着色器需要添加精度声明
if (type == GL_FRAGMENT_SHADER) {
result += "precision mediump float;\n";
}
result += source;
return result;
std::string Shader::addVersionIfNeeded(const std::string &source, GLenum type) {
// 如果已经包含版本声明，直接返回
if (source.find("#version") != std::string::npos) {
return source;
}
// 添加 OpenGL ES 3.2 版本声明
std::string result = "#version 320 es\n";
// 片段着色器需要添加精度声明
if (type == GL_FRAGMENT_SHADER) {
result += "precision mediump float;\n";
}
result += source;
return result;
}
} // namespace extra2d

190
src/scene/director.cpp
View File

@ -1,154 +1,140 @@
#include <scene/director.h>
#include <scene/components/camera_component.h>
#include <event/events.h>
#include <scene/components/camera_component.h>
#include <scene/director.h>
#include <utils/logger.h>
namespace extra2d {
Director::Director() {
}
Director::Director() {}
Director::~Director() {
shutdown();
}
Director::~Director() { shutdown(); }
bool Director::init() {
return true;
}
bool Director::init() { return true; }
void Director::shutdown() {
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
runningScene_.reset();
}
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
runningScene_.reset();
}
// 清空场景栈
while (!sceneStack_.empty()) {
sceneStack_.pop();
}
// 清空场景栈
while (!sceneStack_.empty()) {
sceneStack_.pop();
}
running_ = false;
running_ = false;
}
void Director::runScene(Ptr<Scene> scene) {
if (!scene) return;
if (!scene)
return;
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
}
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
}
// 清空场景栈
while (!sceneStack_.empty()) {
sceneStack_.pop();
}
// 清空场景栈
while (!sceneStack_.empty()) {
sceneStack_.pop();
}
// 运行新场景
runningScene_ = scene;
runningScene_->onEnter();
running_ = true;
needEnd_ = false;
// 运行新场景
runningScene_ = scene;
runningScene_->onEnter();
running_ = true;
needEnd_ = false;
}
void Director::replaceScene(Ptr<Scene> scene) {
if (!scene) return;
if (!scene)
return;
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
}
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
}
// 替换场景
runningScene_ = scene;
runningScene_->onEnter();
// 替换场景
runningScene_ = scene;
runningScene_->onEnter();
}
void Director::pushScene(Ptr<Scene> scene) {
if (!scene) return;
if (!scene)
return;
// 暂停当前场景
if (runningScene_) {
// 可以在这里添加暂停逻辑
sceneStack_.push(runningScene_);
}
// 暂停当前场景
if (runningScene_) {
// 可以在这里添加暂停逻辑
sceneStack_.push(runningScene_);
}
// 运行新场景
runningScene_ = scene;
runningScene_->onEnter();
// 运行新场景
runningScene_ = scene;
runningScene_->onEnter();
}
void Director::popScene() {
if (sceneStack_.empty()) {
// 没有场景可以弹出，结束运行
end();
return;
}
if (sceneStack_.empty()) {
// 没有场景可以弹出，结束运行
end();
return;
}
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
}
// 结束当前场景
if (runningScene_) {
runningScene_->onExit();
}
// 弹出栈顶场景
runningScene_ = sceneStack_.top();
sceneStack_.pop();
// 弹出栈顶场景
runningScene_ = sceneStack_.top();
sceneStack_.pop();
// 恢复场景
// 可以在这里添加恢复逻辑
// 恢复场景
// 可以在这里添加恢复逻辑
}
void Director::end() {
needEnd_ = true;
running_ = false;
needEnd_ = true;
running_ = false;
if (runningScene_) {
runningScene_->onExit();
runningScene_.reset();
}
if (runningScene_) {
runningScene_->onExit();
runningScene_.reset();
}
}
Scene* Director::getRunningScene() const {
return runningScene_.get();
}
Scene *Director::getRunningScene() const { return runningScene_.get(); }
CameraComponent* Director::getMainCamera() const {
if (runningScene_) {
return runningScene_->getMainCamera();
}
return nullptr;
CameraComponent *Director::getMainCamera() const {
if (runningScene_) {
return runningScene_->getMainCamera();
}
return nullptr;
}
void Director::update(float dt) {
if (!running_ || !runningScene_) return;
if (!running_ || !runningScene_)
return;
runningScene_->update(dt);
runningScene_->update(dt);
}
void Director::render() {
if (!running_ || !runningScene_) return;
if (!running_ || !runningScene_)
return;
// 从场景获取相机并上传矩阵
CameraComponent* camera = runningScene_->getMainCamera();
if (camera) {
Mat4 viewProj = camera->getViewProjectionMatrix();
// 调试输出：打印视图投影矩阵
static bool logged = false;
if (!logged) {
const float* m = glm::value_ptr(viewProj);
E2D_LOG_INFO("ViewProjection Matrix:");
E2D_LOG_INFO(" {:.4f} {:.4f} {:.4f} {:.4f}", m[0], m[4], m[8], m[12]);
E2D_LOG_INFO(" {:.4f} {:.4f} {:.4f} {:.4f}", m[1], m[5], m[9], m[13]);
E2D_LOG_INFO(" {:.4f} {:.4f} {:.4f} {:.4f}", m[2], m[6], m[10], m[14]);
E2D_LOG_INFO(" {:.4f} {:.4f} {:.4f} {:.4f}", m[3], m[7], m[11], m[15]);
logged = true;
}
events::OnRenderSetCamera::emit(viewProj);
}
// 从场景获取相机并上传矩阵
CameraComponent *camera = runningScene_->getMainCamera();
if (camera) {
Mat4 viewProj = camera->getViewProjectionMatrix();
runningScene_->render();
events::OnRenderSetCamera::emit(viewProj);
}
runningScene_->render();
}
} // namespace extra2d