Nanako/AronaCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

格式化代码

Browse Source
This commit is contained in:
Nanako 2024-02-19 01:33:18 +08:00
parent e50fcb1992
commit 87ad4d5eb9
23 changed files with 153 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
core/application/application.cpp
View File

@ -14,16 +14,16 @@
bool g_is_running = true; bool g_is_running = true;
bool g_exit_requested = false; bool g_exit_requested = false;
application *g_app_instance = nullptr; application* g_app_instance = nullptr;
static void glfw_error_callback(int error, const char *description) { static void glfw_error_callback(int error, const char* description) {
spdlog::error("Glfw Error {}: {}", error, description); spdlog::error("Glfw Error {}: {}", error, description);
} }
void application::init(window_params in_window_params, int argc, char **argv) { void application::init(window_params in_window_params, int argc, char** argv) {
try { try {
async_spdlog_ = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/log.txt"); async_spdlog_ = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/log.txt");
} catch (const spdlog::spdlog_ex &ex) { } catch (const spdlog::spdlog_ex& ex) {
std::cout << "Log init failed: " << ex.what() << std::endl; std::cout << "Log init failed: " << ex.what() << std::endl;
} }
@ -35,7 +35,7 @@ void application::init(window_params in_window_params, int argc, char **argv) {
renderer_->pre_init(); renderer_->pre_init();
// new SDL window // new glfw window
window_ = glfwCreateWindow(in_window_params.width, in_window_params.height, in_window_params.title.c_str(), nullptr, window_ = glfwCreateWindow(in_window_params.width, in_window_params.height, in_window_params.title.c_str(), nullptr,
nullptr); nullptr);
if (!window_) { if (!window_) {
@ -75,10 +75,10 @@ void application::shutdown() {
destroy_glfw(); destroy_glfw();
} }
std::shared_ptr<texture> application::load_texture(const std::string &path) const { std::shared_ptr<texture> application::load_texture(const std::string& path) const {
int width = 0; int width = 0;
int height = 0; int height = 0;
unsigned char *image_data = stbi_load(path.c_str(), &width, &height, nullptr, 4); unsigned char* image_data = stbi_load(path.c_str(), &width, &height, nullptr, 4);
if (!image_data) { if (!image_data) {
spdlog::error("Failed to load texture: {}", path.c_str()); spdlog::error("Failed to load texture: {}", path.c_str());
return nullptr; return nullptr;
@ -89,7 +89,7 @@ std::shared_ptr<texture> application::load_texture(const std::string &path) cons
} }
std::shared_ptr<texture> std::shared_ptr<texture>
application::create_texture(const unsigned char *data, const int width, const int height) const { application::create_texture(const unsigned char* data, const int width, const int height) const {
return renderer_->create_texture(data, width, height); return renderer_->create_texture(data, width, height);
} }
@ -114,7 +114,7 @@ void application::init_imgui() {
// Setup Dear ImGui context // Setup Dear ImGui context
IMGUI_CHECKVERSION(); IMGUI_CHECKVERSION();
init_imgui(ImGui::CreateContext()); init_imgui(ImGui::CreateContext());
ImGuiIO &io = ImGui::GetIO(); ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
ImGui::StyleColorsDark(); ImGui::StyleColorsDark();

30
core/application/application.h
View File

@ -11,7 +11,7 @@ class application;
extern bool g_is_running; extern bool g_is_running;
extern bool g_exit_requested; extern bool g_exit_requested;
extern application *g_app_instance; extern application* g_app_instance;
struct window_params { struct window_params {
std::string title; std::string title;
@ -34,15 +34,15 @@ public:
virtual ~application() = default; virtual ~application() = default;
application(const application &) = delete; application(const application&) = delete;
application(application &&) = delete; application(application&&) = delete;
static application *get() { static application* get() {
return g_app_instance; return g_app_instance;
} }
virtual void init(window_params in_window_params, int argc, char **argv); virtual void init(window_params in_window_params, int argc, char** argv);
virtual int run(); virtual int run();
@ -50,29 +50,29 @@ public:
virtual void draw_gui() = 0; virtual void draw_gui() = 0;
virtual const char *get_shader_path() = 0; virtual const char* get_shader_path() = 0;
virtual void init_imgui(ImGuiContext *in_context) = 0; virtual void init_imgui(ImGuiContext* in_context) = 0;
[[nodiscard]] std::shared_ptr<texture> load_texture(const std::string &path) const; [[nodiscard]] std::shared_ptr<texture> load_texture(const std::string& path) const;
std::shared_ptr<texture> create_texture(const unsigned char *data, int width, int height) const; std::shared_ptr<texture> create_texture(const unsigned char* data, int width, int height) const;
[[nodiscard]] std::shared_ptr<render_target> create_render_target(int width, int height, [[nodiscard]] std::shared_ptr<render_target> create_render_target(int width, int height,
texture_format format) const; texture_format format) const;
[[nodiscard]] std::shared_ptr<pixel_shader_drawer> create_pixel_shader_drawer() const; [[nodiscard]] std::shared_ptr<pixel_shader_drawer> create_pixel_shader_drawer() const;
[[nodiscard]] virtual const char *get_entry_model() const = 0; [[nodiscard]] virtual const char* get_entry_model() const = 0;
[[nodiscard]] virtual const char *get_draw_ps_vertex_shader_entry() const = 0; // Vertex Shader used for drawing ps [[nodiscard]] virtual const char* get_draw_ps_vertex_shader_entry() const = 0; // Vertex Shader used for drawing ps
[[nodiscard]] renderer *get_renderer() const { return renderer_; } [[nodiscard]] renderer* get_renderer() const { return renderer_; }
[[nodiscard]] GLFWwindow *get_window() const { return window_; } [[nodiscard]] GLFWwindow* get_window() const { return window_; }
protected: protected:
renderer *renderer_ = nullptr; renderer* renderer_ = nullptr;
GLFWwindow *window_ = nullptr; GLFWwindow* window_ = nullptr;
std::shared_ptr<spdlog::logger> async_spdlog_; std::shared_ptr<spdlog::logger> async_spdlog_;
private: private:

10
core/application/command_line.cpp
View File

@ -1,6 +1,6 @@
#include "command_line.h" #include "command_line.h"
void command_line::init(int argc, char **argv) { void command_line::init(int argc, char** argv) {
// parser argv // parser argv
args_.clear(); args_.clear();
for (int i = 0; i < argc; ++i) { for (int i = 0; i < argc; ++i) {
@ -20,7 +20,7 @@ void command_line::init(int argc, char **argv) {
} }
} }
void command_line::get_arg(const std::string &key, std::string &out) const { void command_line::get_arg(const std::string& key, std::string& out) const {
const auto it = args_.find(key); const auto it = args_.find(key);
if (it != args_.end()) { if (it != args_.end()) {
out = it->second; out = it->second;
@ -29,7 +29,7 @@ void command_line::get_arg(const std::string &key, std::string &out) const {
} }
} }
void command_line::get_arg(const std::string &key, int &out) const { void command_line::get_arg(const std::string& key, int& out) const {
const auto it = args_.find(key); const auto it = args_.find(key);
if (it != args_.end()) { if (it != args_.end()) {
out = std::stoi(it->second); out = std::stoi(it->second);
@ -38,7 +38,7 @@ void command_line::get_arg(const std::string &key, int &out) const {
} }
} }
void command_line::get_arg(const std::string &key, float &out) const { void command_line::get_arg(const std::string& key, float& out) const {
const auto it = args_.find(key); const auto it = args_.find(key);
if (it != args_.end()) { if (it != args_.end()) {
out = std::stof(it->second); out = std::stof(it->second);
@ -47,7 +47,7 @@ void command_line::get_arg(const std::string &key, float &out) const {
} }
} }
void command_line::get_arg(const std::string &key, bool &out) const { void command_line::get_arg(const std::string& key, bool& out) const {
const auto it = args_.find(key); const auto it = args_.find(key);
if (it != args_.end()) { if (it != args_.end()) {
out = it->second != "false"; out = it->second != "false";

12
core/application/command_line.h
View File

@ -4,20 +4,20 @@
class command_line { class command_line {
public: public:
static command_line &instance() { static command_line& instance() {
static command_line instance; static command_line instance;
return instance; return instance;
} }
void init(int argc, char **argv); void init(int argc, char** argv);
void get_arg(const std::string &key, std::string &out) const; void get_arg(const std::string& key, std::string& out) const;
void get_arg(const std::string &key, int &out) const; void get_arg(const std::string& key, int& out) const;
void get_arg(const std::string &key, float &out) const; void get_arg(const std::string& key, float& out) const;
void get_arg(const std::string &key, bool &out) const; void get_arg(const std::string& key, bool& out) const;
private: private:
std::map<std::string, std::string> args_; // key-value pairs std::map<std::string, std::string> args_; // key-value pairs

50
core/misc/ref_counting.h
View File

@ -6,20 +6,20 @@
*/ */
template<typename ReferencedType> template<typename ReferencedType>
class ref_count_ptr { class ref_count_ptr {
typedef ReferencedType *reference_type; typedef ReferencedType* reference_type;
public: public:
ref_count_ptr(): reference_(nullptr) { ref_count_ptr(): reference_(nullptr) {
} }
explicit ref_count_ptr(ReferencedType *in_reference, bool bAddRef = true) { explicit ref_count_ptr(ReferencedType* in_reference, bool bAddRef = true) {
reference_ = in_reference; reference_ = in_reference;
if (reference_ && bAddRef) { if (reference_ && bAddRef) {
reference_->AddRef(); reference_->AddRef();
} }
} }
ref_count_ptr(const ref_count_ptr &copy) { ref_count_ptr(const ref_count_ptr& copy) {
reference_ = copy.reference_; reference_ = copy.reference_;
if (reference_) { if (reference_) {
reference_->AddRef(); reference_->AddRef();
@ -27,21 +27,21 @@ public:
} }
template<typename CopyReferencedType> template<typename CopyReferencedType>
explicit ref_count_ptr(const ref_count_ptr<CopyReferencedType> &copy) { explicit ref_count_ptr(const ref_count_ptr<CopyReferencedType>& copy) {
reference_ = static_cast<ReferencedType *>(copy.get_reference()); reference_ = static_cast<ReferencedType*>(copy.get_reference());
if (reference_) { if (reference_) {
reference_->AddRef(); reference_->AddRef();
} }
} }
ref_count_ptr(ref_count_ptr &&move) noexcept { ref_count_ptr(ref_count_ptr&& move) noexcept {
reference_ = move.reference_; reference_ = move.reference_;
move.reference_ = nullptr; move.reference_ = nullptr;
} }
template<typename MoveReferencedType> template<typename MoveReferencedType>
explicit ref_count_ptr(ref_count_ptr<MoveReferencedType> &&move) { explicit ref_count_ptr(ref_count_ptr<MoveReferencedType>&& move) {
reference_ = static_cast<ReferencedType *>(move.get_reference()); reference_ = static_cast<ReferencedType*>(move.get_reference());
move.reference_ = nullptr; move.reference_ = nullptr;
} }
@ -51,10 +51,10 @@ public:
} }
} }
ref_count_ptr &operator=(ReferencedType *in_reference) { ref_count_ptr& operator=(ReferencedType* in_reference) {
if (reference_ != in_reference) { if (reference_ != in_reference) {
// Call AddRef before Release, in case the new reference is the same as the old reference. // Call AddRef before Release, in case the new reference is the same as the old reference.
ReferencedType *old_reference = reference_; ReferencedType* old_reference = reference_;
reference_ = in_reference; reference_ = in_reference;
if (reference_) { if (reference_) {
reference_->AddRef(); reference_->AddRef();
@ -66,18 +66,18 @@ public:
return *this; return *this;
} }
ref_count_ptr &operator=(const ref_count_ptr &in_ptr) { ref_count_ptr& operator=(const ref_count_ptr& in_ptr) {
return *this = in_ptr.reference_; return *this = in_ptr.reference_;
} }
template<typename CopyReferencedType> template<typename CopyReferencedType>
ref_count_ptr &operator=(const ref_count_ptr<CopyReferencedType> &in_ptr) { ref_count_ptr& operator=(const ref_count_ptr<CopyReferencedType>& in_ptr) {
return *this = in_ptr.GetReference(); return *this = in_ptr.GetReference();
} }
ref_count_ptr &operator=(ref_count_ptr &&in_ptr) noexcept { ref_count_ptr& operator=(ref_count_ptr&& in_ptr) noexcept {
if (this != &in_ptr) { if (this != &in_ptr) {
ReferencedType *old_reference = reference_; ReferencedType* old_reference = reference_;
reference_ = in_ptr.reference_; reference_ = in_ptr.reference_;
in_ptr.reference_ = nullptr; in_ptr.reference_ = nullptr;
if (old_reference) { if (old_reference) {
@ -88,9 +88,9 @@ public:
} }
template<typename MoveReferencedType> template<typename MoveReferencedType>
ref_count_ptr &operator=(ref_count_ptr<MoveReferencedType> &&in_ptr) { ref_count_ptr& operator=(ref_count_ptr<MoveReferencedType>&& in_ptr) {
// InPtr is a different type (or we would have called the other operator), so we need not test &InPtr != this // InPtr is a different type (or we would have called the other operator), so we need not test &InPtr != this
ReferencedType *old_reference = reference_; ReferencedType* old_reference = reference_;
reference_ = in_ptr.reference_; reference_ = in_ptr.reference_;
in_ptr.reference_ = nullptr; in_ptr.reference_ = nullptr;
if (old_reference) { if (old_reference) {
@ -99,7 +99,7 @@ public:
return *this; return *this;
} }
ReferencedType *operator->() const { ReferencedType* operator->() const {
return reference_; return reference_;
} }
@ -107,16 +107,16 @@ public:
return reference_; return reference_;
} }
ReferencedType **get_init_reference() { ReferencedType** get_init_reference() {
*this = nullptr; *this = nullptr;
return &reference_; return &reference_;
} }
ReferencedType *get_reference() const { ReferencedType* get_reference() const {
return reference_; return reference_;
} }
friend bool is_valid_ref(const ref_count_ptr &in_reference) { friend bool is_valid_ref(const ref_count_ptr& in_reference) {
return in_reference.reference_ != nullptr; return in_reference.reference_ != nullptr;
} }
@ -138,9 +138,9 @@ public:
return result; return result;
} }
void swap(ref_count_ptr &in_ptr) noexcept // this does not change the reference count, and so is faster void swap(ref_count_ptr& in_ptr) noexcept // this does not change the reference count, and so is faster
{ {
ReferencedType *old_reference = reference_; ReferencedType* old_reference = reference_;
reference_ = in_ptr.reference_; reference_ = in_ptr.reference_;
in_ptr.reference_ = old_reference; in_ptr.reference_ = old_reference;
} }
@ -156,17 +156,17 @@ public:
// } // }
private: private:
ReferencedType *reference_; ReferencedType* reference_;
template<typename OtherType> template<typename OtherType>
friend class ref_count_ptr; friend class ref_count_ptr;
public: public:
bool operator==(const ref_count_ptr &b) const { bool operator==(const ref_count_ptr& b) const {
return get_reference() == b.get_reference(); return get_reference() == b.get_reference();
} }
bool operator==(ReferencedType *b) const { bool operator==(ReferencedType* b) const {
return get_reference() == b; return get_reference() == b;
} }
}; };

16
core/misc/scope_exit.h
View File

@ -10,18 +10,18 @@ namespace scope_exit_support {
*/ */
template<typename FuncType> template<typename FuncType>
class scope_guard { class scope_guard {
scope_guard(scope_guard &&) = delete; scope_guard(scope_guard&&) = delete;
scope_guard(const scope_guard &) = delete; scope_guard(const scope_guard&) = delete;
scope_guard &operator=(scope_guard &&) = delete; scope_guard& operator=(scope_guard&&) = delete;
scope_guard &operator=(const scope_guard &) = delete; scope_guard& operator=(const scope_guard&) = delete;
public: public:
// Given a lambda, constructs an RAII scope guard. // Given a lambda, constructs an RAII scope guard.
explicit scope_guard(FuncType &&InFunc) explicit scope_guard(FuncType&& InFunc)
: func_((FuncType &&) InFunc) { : func_((FuncType&&) InFunc) {
} }
// Causes the lambda to be executed. // Causes the lambda to be executed.
@ -36,8 +36,8 @@ namespace scope_exit_support {
struct scope_guard_syntax_support { struct scope_guard_syntax_support {
template<typename FuncType> template<typename FuncType>
scope_guard<FuncType> operator+(FuncType &&in_func) { scope_guard<FuncType> operator+(FuncType&& in_func) {
return scope_guard<FuncType>((FuncType &&) in_func); return scope_guard<FuncType>((FuncType&&) in_func);
} }
}; };
} }

14
core/rhi/opengl/pixel_shader_drawer_opengl.cpp
View File

@ -5,9 +5,9 @@
#include "shader/shader_ps_opengl.h" #include "shader/shader_ps_opengl.h"
#include "shader/shader_vs_opengl.h" #include "shader/shader_vs_opengl.h"
void ps_opengl_compute_callback(const ImDrawList *parent_list, const ImDrawCmd *cmd) { void ps_opengl_compute_callback(const ImDrawList* parent_list, const ImDrawCmd* cmd) {
const auto data = static_cast<pixel_shader_drawer_opengl *>(cmd->UserCallbackData); const auto data = static_cast<pixel_shader_drawer_opengl*>(cmd->UserCallbackData);
const std::shared_ptr<render_target_opengl> &rt = data->rt; const std::shared_ptr<render_target_opengl>& rt = data->rt;
const auto program = data->program; const auto program = data->program;
program->use_program(); program->use_program();
@ -37,10 +37,10 @@ void ps_opengl_compute_callback(const ImDrawList *parent_list, const ImDrawCmd *
glScissor(0, 0, width, height); glScissor(0, 0, width, height);
// glScissor((int)clip_min.x, (int)(0 - clip_max.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y)); // glScissor((int)clip_min.x, (int)(0 - clip_max.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y));
ImDrawVert &vert1 = data->vtx_buffer[0]; ImDrawVert& vert1 = data->vtx_buffer[0];
ImDrawVert &vert2 = data->vtx_buffer[1]; ImDrawVert& vert2 = data->vtx_buffer[1];
ImDrawVert &vert3 = data->vtx_buffer[2]; ImDrawVert& vert3 = data->vtx_buffer[2];
ImDrawVert &vert4 = data->vtx_buffer[3]; ImDrawVert& vert4 = data->vtx_buffer[3];
vert1.pos = ImVec2(0, 0); vert1.pos = ImVec2(0, 0);
vert2.pos = ImVec2(width, 0); vert2.pos = ImVec2(width, 0);
vert3.pos = ImVec2(width, height); vert3.pos = ImVec2(width, height);

2
core/rhi/opengl/render_target_opengl.cpp
View File

@ -112,7 +112,7 @@ render_target_opengl::~render_target_opengl() {
glDeleteTextures(1, &texture_); glDeleteTextures(1, &texture_);
} }
void *render_target_opengl::lock(lock_state state) { void* render_target_opengl::lock(lock_state state) {
locked_texture_ = malloc(width_ * height_ * 4); locked_texture_ = malloc(width_ * height_ * 4);
switch (state) { switch (state) {
case lock_state::READ: case lock_state::READ:

6
core/rhi/opengl/render_target_opengl.h
View File

@ -8,12 +8,12 @@ public:
~render_target_opengl() override; ~render_target_opengl() override;
ImTextureID get_texture_id() override { return (void *) static_cast<intptr_t>(texture_); } ImTextureID get_texture_id() override { return (void*) static_cast<intptr_t>(texture_); }
[[nodiscard]] GLuint get_fbo() const { return fbo_; } [[nodiscard]] GLuint get_fbo() const { return fbo_; }
[[nodiscard]] GLuint get_texture() const { return texture_; } [[nodiscard]] GLuint get_texture() const { return texture_; }
[[nodiscard]] GLint get_internal_format() const { return internal_format_; } [[nodiscard]] GLint get_internal_format() const { return internal_format_; }
void *lock(lock_state state) override; void* lock(lock_state state) override;
void unlock() override; void unlock() override;
@ -24,5 +24,5 @@ private:
GLuint fbo_ = 0; GLuint fbo_ = 0;
GLuint texture_ = 0; GLuint texture_ = 0;
GLint internal_format_ = 0; GLint internal_format_ = 0;
void *locked_texture_ = nullptr; void* locked_texture_ = nullptr;
}; };

10
core/rhi/opengl/renderer_opengl.cpp
View File

@ -35,7 +35,7 @@ void renderer_opengl::pre_init() {
#endif #endif
} }
bool renderer_opengl::init(GLFWwindow *window_handle) { bool renderer_opengl::init(GLFWwindow* window_handle) {
if (has_initialized_) if (has_initialized_)
return true; return true;
@ -72,7 +72,7 @@ void renderer_opengl::post_shutdown() {
renderer::post_shutdown(); renderer::post_shutdown();
} }
std::shared_ptr<shader> renderer_opengl::load_shader(const std::string &entry_name) { std::shared_ptr<shader> renderer_opengl::load_shader(const std::string& entry_name) {
return nullptr; return nullptr;
} }
@ -80,14 +80,14 @@ std::shared_ptr<pixel_shader_drawer> renderer_opengl::create_pixel_shader_drawer
return std::make_shared<pixel_shader_drawer_opengl>(); return std::make_shared<pixel_shader_drawer_opengl>();
} }
void renderer_opengl::new_frame(GLFWwindow *window_handle) { void renderer_opengl::new_frame(GLFWwindow* window_handle) {
// Start the Dear ImGui frame // Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
} }
void renderer_opengl::end_frame(GLFWwindow *window_handle) { void renderer_opengl::end_frame(GLFWwindow* window_handle) {
// Rendering // Rendering
ImGui::Render(); ImGui::Render();
int display_w, display_h; int display_w, display_h;
@ -104,7 +104,7 @@ void renderer_opengl::end_frame(GLFWwindow *window_handle) {
void renderer_opengl::resize(int width, int height) { void renderer_opengl::resize(int width, int height) {
} }
std::shared_ptr<texture> renderer_opengl::create_texture(const unsigned char *data, int width, int height) { std::shared_ptr<texture> renderer_opengl::create_texture(const unsigned char* data, int width, int height) {
auto out = std::make_shared<texture_opengl>(); auto out = std::make_shared<texture_opengl>();
if (!out->init_data(data, width, height)) { if (!out->init_data(data, width, height)) {
out = nullptr; out = nullptr;

10
core/rhi/opengl/renderer_opengl.h
View File

@ -5,23 +5,23 @@ class renderer_opengl : public renderer {
public: public:
void pre_init() override; void pre_init() override;
bool init(GLFWwindow *window_handle) override; bool init(GLFWwindow* window_handle) override;
void shutdown() override; void shutdown() override;
void post_shutdown() override; void post_shutdown() override;
std::shared_ptr<shader> load_shader(const std::string &entry_name) override; std::shared_ptr<shader> load_shader(const std::string& entry_name) override;
std::shared_ptr<pixel_shader_drawer> create_pixel_shader_drawer() override; std::shared_ptr<pixel_shader_drawer> create_pixel_shader_drawer() override;
void new_frame(GLFWwindow *window_handle) override; void new_frame(GLFWwindow* window_handle) override;
void end_frame(GLFWwindow *window_handle) override; void end_frame(GLFWwindow* window_handle) override;
void resize(int width, int height) override; void resize(int width, int height) override;
std::shared_ptr<texture> create_texture(const unsigned char *data, int width, int height) override; std::shared_ptr<texture> create_texture(const unsigned char* data, int width, int height) override;
std::shared_ptr<render_target> create_render_target(int width, int height, texture_format format) override; std::shared_ptr<render_target> create_render_target(int width, int height, texture_format format) override;

8
core/rhi/opengl/shader/shader_opengl.cpp
View File

@ -42,22 +42,22 @@ void shader_opengl::set_using_program(std::shared_ptr<shader_program_opengl> in_
using_program_ = in_program; using_program_ = in_program;
} }
void shader_opengl::set_cbuffer(const char *name, void *buffer, int size) { void shader_opengl::set_cbuffer(const char* name, void* buffer, int size) {
if (const auto program = using_program_.lock()) if (const auto program = using_program_.lock())
program->set_uniform(name, buffer, size); program->set_uniform(name, buffer, size);
} }
void shader_opengl::set_uav_buffer(const char *name, void *buffer, int size, int element_size) { void shader_opengl::set_uav_buffer(const char* name, void* buffer, int size, int element_size) {
if (const auto program = using_program_.lock()) if (const auto program = using_program_.lock())
program->set_ssbo(name, buffer, size, element_size); program->set_ssbo(name, buffer, size, element_size);
} }
void shader_opengl::set_render_target(const char *name, std::shared_ptr<render_target> in_render_target) { void shader_opengl::set_render_target(const char* name, std::shared_ptr<render_target> in_render_target) {
if (const auto program = using_program_.lock()) if (const auto program = using_program_.lock())
program->set_render_target(name, in_render_target); program->set_render_target(name, in_render_target);
} }
void shader_opengl::set_texture(const char *name, std::shared_ptr<texture> in_texture) { void shader_opengl::set_texture(const char* name, std::shared_ptr<texture> in_texture) {
if (const auto program = using_program_.lock()) if (const auto program = using_program_.lock())
program->set_texture(name, in_texture); program->set_texture(name, in_texture);
} }

12
core/rhi/opengl/shader/shader_opengl.h
View File

@ -36,20 +36,20 @@ public:
void set_using_program(std::shared_ptr<shader_program_opengl> in_program); void set_using_program(std::shared_ptr<shader_program_opengl> in_program);
void set_cbuffer(const char *name, void *buffer, int size) override; void set_cbuffer(const char* name, void* buffer, int size) override;
void set_uav_buffer(const char *name, void *buffer, int size, int element_size) override; void set_uav_buffer(const char* name, void* buffer, int size, int element_size) override;
void set_render_target(const char *name, std::shared_ptr<render_target> in_render_target) override; void set_render_target(const char* name, std::shared_ptr<render_target> in_render_target) override;
void set_texture(const char *name, std::shared_ptr<texture> in_texture) override; void set_texture(const char* name, std::shared_ptr<texture> in_texture) override;
[[nodiscard]] virtual GLenum get_shader_type() const = 0; [[nodiscard]] virtual GLenum get_shader_type() const = 0;
[[nodiscard]] GLuint get_shader_id() const { return shader_id_; } [[nodiscard]] GLuint get_shader_id() const { return shader_id_; }
[[nodiscard]] const std::map<std::string, opengl_uniform_data> &get_uniform_map() const { return uniform_map_; } [[nodiscard]] const std::map<std::string, opengl_uniform_data>& get_uniform_map() const { return uniform_map_; }
[[nodiscard]] const std::map<std::string, opengl_texture_data> &get_texture_map() const { return texture_map_; } [[nodiscard]] const std::map<std::string, opengl_texture_data>& get_texture_map() const { return texture_map_; }
protected: protected:
GLuint shader_id_; GLuint shader_id_;

30
core/rhi/opengl/shader/shader_program_opengl.cpp
View File

@ -105,7 +105,7 @@ bool shader_program_opengl::create_program(std::shared_ptr<shader_opengl> in_com
} }
void shader_program_opengl::destroy_program() { void shader_program_opengl::destroy_program() {
for (const auto &val: ubo_map_ | std::views::values) for (const auto& val: ubo_map_ | std::views::values)
glDeleteBuffers(1, &val); glDeleteBuffers(1, &val);
if (const auto shader = pixel_shader_.lock()) if (const auto shader = pixel_shader_.lock())
@ -123,12 +123,12 @@ void shader_program_opengl::destroy_program() {
texture_map_.clear(); texture_map_.clear();
} }
void shader_program_opengl::set_uniform(const char *slang_name, void *buffer, int size) { void shader_program_opengl::set_uniform(const char* slang_name, void* buffer, int size) {
const auto &uniform_name = uniform_map_.find(slang_name); const auto& uniform_name = uniform_map_.find(slang_name);
if (uniform_name == uniform_map_.end()) if (uniform_name == uniform_map_.end())
return; return;
const auto &uniform_data = uniform_name->second; const auto& uniform_data = uniform_name->second;
GLuint using_bind_point = uniform_data.binding; GLuint using_bind_point = uniform_data.binding;
const auto find_ubo = ubo_map_.find(using_bind_point); const auto find_ubo = ubo_map_.find(using_bind_point);
if (find_ubo != ubo_map_.end()) { if (find_ubo != ubo_map_.end()) {
@ -152,11 +152,11 @@ void shader_program_opengl::set_uniform(const char *slang_name, void *buffer, in
ubo_map_.insert(std::pair(using_bind_point, ubo)); ubo_map_.insert(std::pair(using_bind_point, ubo));
} }
void shader_program_opengl::set_ssbo(const char *slang_name, void *buffer, int size, int element_size) { void shader_program_opengl::set_ssbo(const char* slang_name, void* buffer, int size, int element_size) {
const auto &uniform_name = uniform_map_.find(slang_name); const auto& uniform_name = uniform_map_.find(slang_name);
if (uniform_name == uniform_map_.end()) if (uniform_name == uniform_map_.end())
return; return;
const auto &uniform_data = uniform_name->second; const auto& uniform_data = uniform_name->second;
const GLint location = glGetProgramResourceIndex(program_id_, GL_SHADER_STORAGE_BLOCK, uniform_data.name.c_str()); const GLint location = glGetProgramResourceIndex(program_id_, GL_SHADER_STORAGE_BLOCK, uniform_data.name.c_str());
if (location == -1) { if (location == -1) {
spdlog::error("Failed to find ssbo: {}", slang_name); spdlog::error("Failed to find ssbo: {}", slang_name);
@ -164,32 +164,32 @@ void shader_program_opengl::set_ssbo(const char *slang_name, void *buffer, int s
} }
} }
void shader_program_opengl::set_render_target(const char *name, std::shared_ptr<render_target> in_render_target) { void shader_program_opengl::set_render_target(const char* name, std::shared_ptr<render_target> in_render_target) {
const auto &texture_name = texture_map_.find(name); const auto& texture_name = texture_map_.find(name);
if (texture_name == texture_map_.end()) if (texture_name == texture_map_.end())
return; return;
std::shared_ptr<render_target_opengl> rt = std::static_pointer_cast<render_target_opengl>(in_render_target); std::shared_ptr<render_target_opengl> rt = std::static_pointer_cast<render_target_opengl>(in_render_target);
const opengl_texture_data &texture_data = texture_name->second; const opengl_texture_data& texture_data = texture_name->second;
if (texture_data.format != rt->get_internal_format()) if (texture_data.format != rt->get_internal_format())
spdlog::error("Mismatched texture format: {}, need{}, yours {}", name, texture_data.format, spdlog::error("Mismatched texture format: {}, need{}, yours {}", name, texture_data.format,
rt->get_internal_format()); rt->get_internal_format());
glBindImageTexture(texture_data.binding, rt->get_texture(), 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F); glBindImageTexture(texture_data.binding, rt->get_texture(), 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
} }
void shader_program_opengl::set_texture(const char *name, std::shared_ptr<texture> in_texture) { void shader_program_opengl::set_texture(const char* name, std::shared_ptr<texture> in_texture) {
const auto &texture_name = texture_map_.find(name); const auto& texture_name = texture_map_.find(name);
if (texture_name == texture_map_.end()) if (texture_name == texture_map_.end())
return; return;
std::shared_ptr<texture_opengl> t = std::static_pointer_cast<texture_opengl>(in_texture); std::shared_ptr<texture_opengl> t = std::static_pointer_cast<texture_opengl>(in_texture);
const opengl_texture_data &texture_data = texture_name->second; const opengl_texture_data& texture_data = texture_name->second;
glBindImageTexture(texture_data.binding, t->get_texture(), 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F); glBindImageTexture(texture_data.binding, t->get_texture(), 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
} }
void shader_program_opengl::update_param_map(std::shared_ptr<shader_opengl> in_shader) { void shader_program_opengl::update_param_map(std::shared_ptr<shader_opengl> in_shader) {
const auto &uniform_pairs = in_shader->get_uniform_map(); const auto& uniform_pairs = in_shader->get_uniform_map();
const auto &texture_pairs = in_shader->get_texture_map(); const auto& texture_pairs = in_shader->get_texture_map();
uniform_map_.insert(uniform_pairs.begin(), uniform_pairs.end()); uniform_map_.insert(uniform_pairs.begin(), uniform_pairs.end());
texture_map_.insert(texture_pairs.begin(), texture_pairs.end()); texture_map_.insert(texture_pairs.begin(), texture_pairs.end());

24
core/rhi/opengl/shader/shader_program_opengl.h
View File

@ -35,32 +35,32 @@ public:
void destroy_program(); void destroy_program();
void set_uniform(const char *slang_name, void *buffer, int size); void set_uniform(const char* slang_name, void* buffer, int size);
void set_ssbo(const char *slang_name, void *buffer, int size, int element_size); void set_ssbo(const char* slang_name, void* buffer, int size, int element_size);
void set_render_target(const char *name, std::shared_ptr<render_target> in_render_target); void set_render_target(const char* name, std::shared_ptr<render_target> in_render_target);
void set_texture(const char *name, std::shared_ptr<texture> in_texture); void set_texture(const char* name, std::shared_ptr<texture> in_texture);
template<typename T> template<typename T>
void set_uniform(const char *name, const T &buffer) { void set_uniform(const char* name, const T& buffer) {
set_uniform(name, (void *) &buffer, sizeof(T)); set_uniform(name, (void*) &buffer, sizeof(T));
} }
template<typename T> template<typename T>
void set_uniform(const char *name, const std::vector<T> &buffer) { void set_uniform(const char* name, const std::vector<T>& buffer) {
set_uniform(name, (void *) buffer.data(), sizeof(T) * buffer.size()); set_uniform(name, (void*) buffer.data(), sizeof(T) * buffer.size());
} }
template<typename T> template<typename T>
void set_ssbo(const char *name, const T &buffer) { void set_ssbo(const char* name, const T& buffer) {
set_ssbo(name, (void *) &buffer, sizeof(T), sizeof(T)); set_ssbo(name, (void*) &buffer, sizeof(T), sizeof(T));
} }
template<typename T> template<typename T>
void set_ssbo(const char *name, const std::vector<T> &buffer) { void set_ssbo(const char* name, const std::vector<T>& buffer) {
set_ssbo(name, (void *) buffer.data(), sizeof(T) * buffer.size(), sizeof(T)); set_ssbo(name, (void*) buffer.data(), sizeof(T) * buffer.size(), sizeof(T));
} }
[[nodiscard]] bool is_initialized() const { return program_id_ != 0; } [[nodiscard]] bool is_initialized() const { return program_id_ != 0; }

2
core/rhi/opengl/texture_opengl.cpp
View File

@ -8,7 +8,7 @@ texture_opengl::~texture_opengl() {
} }
} }
bool texture_opengl::init_data(const unsigned char *data, int width, int height) { bool texture_opengl::init_data(const unsigned char* data, int width, int height) {
width_ = width; width_ = width;
height_ = height; height_ = height;

4
core/rhi/opengl/texture_opengl.h
View File

@ -6,10 +6,10 @@ class texture_opengl : public texture {
public: public:
~texture_opengl() override; ~texture_opengl() override;
ImTextureID get_texture_id() override { return (void *) static_cast<intptr_t>(texture_id_); } ImTextureID get_texture_id() override { return (void*) static_cast<intptr_t>(texture_id_); }
GLuint get_texture() const { return texture_id_; } GLuint get_texture() const { return texture_id_; }
bool init_data(const unsigned char *data, int width, int height) override; bool init_data(const unsigned char* data, int width, int height) override;
[[nodiscard]] bool is_valid() const override { return texture_id_ != 0; } [[nodiscard]] bool is_valid() const override { return texture_id_ != 0; }

2
core/rhi/render_target.h
View File

@ -27,7 +27,7 @@ public:
on_resize_callback(shared_from_this()); on_resize_callback(shared_from_this());
} }
virtual void *lock(lock_state state) = 0; virtual void* lock(lock_state state) = 0;
virtual void unlock() = 0; virtual void unlock() = 0;

6
core/rhi/renderer.cpp
View File

@ -2,13 +2,11 @@
#include "application/application.h" #include "application/application.h"
void renderer::shutdown() void renderer::shutdown() {
{
default_vs_ = nullptr; default_vs_ = nullptr;
} }
std::shared_ptr<shader> renderer::get_pixel_shader_render_default_vs() std::shared_ptr<shader> renderer::get_pixel_shader_render_default_vs() {
{
if (!default_vs_) if (!default_vs_)
default_vs_ = load_shader(application::get()->get_draw_ps_vertex_shader_entry()); default_vs_ = load_shader(application::get()->get_draw_ps_vertex_shader_entry());
return default_vs_; return default_vs_;

10
core/rhi/renderer.h
View File

@ -19,26 +19,26 @@ public:
virtual void pre_init() { virtual void pre_init() {
} }
virtual bool init(GLFWwindow *window_handle) = 0; virtual bool init(GLFWwindow* window_handle) = 0;
virtual void shutdown(); virtual void shutdown();
virtual void post_shutdown() { virtual void post_shutdown() {
} }
virtual std::shared_ptr<shader> load_shader(const std::string &entry_name) = 0; virtual std::shared_ptr<shader> load_shader(const std::string& entry_name) = 0;
virtual std::shared_ptr<shader> get_pixel_shader_render_default_vs(); virtual std::shared_ptr<shader> get_pixel_shader_render_default_vs();
virtual std::shared_ptr<pixel_shader_drawer> create_pixel_shader_drawer() = 0; virtual std::shared_ptr<pixel_shader_drawer> create_pixel_shader_drawer() = 0;
virtual void new_frame(GLFWwindow *window_handle) = 0; virtual void new_frame(GLFWwindow* window_handle) = 0;
virtual void end_frame(GLFWwindow *window_handle) = 0; virtual void end_frame(GLFWwindow* window_handle) = 0;
virtual void resize(int width, int height) = 0; virtual void resize(int width, int height) = 0;
virtual std::shared_ptr<texture> create_texture(const unsigned char *data, int width, int height) = 0; virtual std::shared_ptr<texture> create_texture(const unsigned char* data, int width, int height) = 0;
virtual std::shared_ptr<render_target> create_render_target(int width, int height, texture_format format) = 0; virtual std::shared_ptr<render_target> create_render_target(int width, int height, texture_format format) = 0;

3
core/rhi/rhi_defintion.h
View File

@ -1,7 +1,6 @@
#pragma once #pragma once
enum class texture_format enum class texture_format {
{
RGBA8, RGBA8,
RGBA16_FLOAT, RGBA16_FLOAT,
RGBA32_FLOAT, RGBA32_FLOAT,

28
core/rhi/shader.h
View File

@ -24,35 +24,35 @@ public:
} }
// param setters // param setters
virtual void set_cbuffer(const char *name, void *buffer, int size) = 0; virtual void set_cbuffer(const char* name, void* buffer, int size) = 0;
virtual void set_uav_buffer(const char *name, void *buffer, int count, int element_size) { virtual void set_uav_buffer(const char* name, void* buffer, int count, int element_size) {
} }
virtual void set_texture(const char *name, std::shared_ptr<texture> in_texture) = 0; virtual void set_texture(const char* name, std::shared_ptr<texture> in_texture) = 0;
virtual void set_render_target(const char *name, std::shared_ptr<render_target> in_render_target) = 0; virtual void set_render_target(const char* name, std::shared_ptr<render_target> in_render_target) = 0;
template<typename T> template<typename T>
void set_cbuffer(const char *name, const T &buffer) { void set_cbuffer(const char* name, const T& buffer) {
set_cbuffer(name, (void *) &buffer, sizeof(T)); set_cbuffer(name, (void*) &buffer, sizeof(T));
} }
template<typename T> template<typename T>
void set_cbuffer(const char *name, const std::vector<T> &buffer) { void set_cbuffer(const char* name, const std::vector<T>& buffer) {
set_cbuffer(name, (void *) buffer.data(), sizeof(T) * buffer.size()); set_cbuffer(name, (void*) buffer.data(), sizeof(T) * buffer.size());
} }
template<typename T> template<typename T>
void set_uav_buffer(const char *name, const T &buffer) { void set_uav_buffer(const char* name, const T& buffer) {
set_uav_buffer(name, (void *) &buffer, sizeof(buffer), sizeof(T)); set_uav_buffer(name, (void*) &buffer, sizeof(buffer), sizeof(T));
} }
template<typename T> template<typename T>
void set_uav_buffer(const char *name, const std::vector<T> &buffer) { void set_uav_buffer(const char* name, const std::vector<T>& buffer) {
set_uav_buffer(name, (void *) buffer.data(), buffer.size(), sizeof(T)); set_uav_buffer(name, (void*) buffer.data(), buffer.size(), sizeof(T));
} }
void begin_draw(const shader_draw_data &in_data) { if (on_begin_draw) on_begin_draw(in_data, *this); } void begin_draw(const shader_draw_data& in_data) { if (on_begin_draw) on_begin_draw(in_data, *this); }
std::function<void(const shader_draw_data &, shader &)> on_begin_draw; std::function<void(const shader_draw_data&, shader&)> on_begin_draw;
}; };

2
core/rhi/texture.h
View File

@ -9,7 +9,7 @@ public:
texture(): width_(0), height_(0) { texture(): width_(0), height_(0) {
} }
virtual bool init_data(const unsigned char *data, int width, int height) = 0; virtual bool init_data(const unsigned char* data, int width, int height) = 0;
[[nodiscard]] virtual bool is_valid() const = 0; [[nodiscard]] virtual bool is_valid() const = 0;