diff --git a/.clang-tidy b/.clang-tidy index 593434a..0b2bb05 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -1,6 +1,6 @@ --- Checks: "clang-diagnostic-*,clang-analyzer-*,cppcoreguidelines-*,modernize-*,-modernize-use-trailing-return-type, - -*-non-private-member-variables-in-classes,-*-magic-numbers" + -*-non-private-member-variables-in-classes,-*-magic-numbers,-*-macro-usage" WarningsAsErrors: true HeaderFilterRegex: "" AnalyzeTemporaryDtors: false diff --git a/CMakeLists.txt b/CMakeLists.txt index 82bb540..e69a6ab 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,12 +21,16 @@ find_package(GLEW REQUIRED) find_package(glfw3 CONFIG REQUIRED) find_package(glm CONFIG REQUIRED) find_package(OpenGL REQUIRED) +find_package(fmt CONFIG REQUIRED) +find_package(spdlog CONFIG REQUIRED) find_package(assimp CONFIG REQUIRED) # Link sources file(GLOB_RECURSE source_list src/*.cpp) add_library(simpleengine STATIC ${source_list}) +target_compile_definitions(simpleengine PUBLIC SPDLOG_FMT_EXTERNAL) + # Link headers target_include_directories(simpleengine PUBLIC include PRIVATE include/simpleengine) @@ -47,8 +51,12 @@ target_link_libraries(simpleengine PUBLIC ${GLM_LIBRARIES}) target_link_libraries(simpleengine PUBLIC ${OPENGL_LIBRARIES}) if(WIN32) target_link_libraries(simpleengine PUBLIC assimp::assimp) + target_link_libraries(simpleengine PUBLIC fmt::fmt) + target_link_libraries(simpleengine PUBLIC spdlog::spdlog) else() target_link_libraries(simpleengine PUBLIC assimp) + target_link_libraries(simpleengine PUBLIC fmt) + target_link_libraries(simpleengine PUBLIC spdlog) endif() # Link resources diff --git a/examples/dev_testing/src/main.cpp b/examples/dev_testing/src/main.cpp index 7cdc2ba..fcef86b 100644 --- a/examples/dev_testing/src/main.cpp +++ b/examples/dev_testing/src/main.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -29,6 +30,7 @@ #include #include #include +#include #include #include @@ -62,9 +64,7 @@ public: // Check if the last print was 1 second ago. if (current_time - last_frame_time_tps >= 1.0) { - double ms_per_frame = 1000 / (double)frame_count_tps; - - printf("Fixed update: %d tps, %f ms/frame\n", frame_count_tps, ms_per_frame); + SE_DEBUG("performance", "Fixed update: {}tps", frame_count_tps); frame_count_tps = 0; last_frame_time_tps += 1.0; } @@ -76,11 +76,10 @@ public: // Check if the last print was 1 second ago. if (current_time - last_frame_time_input >= 1.0) { - double ms_per_frame = 1000 / (double)frame_count_input; - - printf("Input: %d tps, %f ms/frame\n", frame_count_input, ms_per_frame); + SE_DEBUG("performance", "Input: {}tps", frame_count_input); frame_count_input = 0; last_frame_time_input += 1.0; + } } @@ -92,7 +91,8 @@ public: if (current_time - last_frame_time_render >= 1.0) { double ms_per_frame = 1000 / (double)frame_count_render; - printf("Render: %d fps, %f ms/frame\n\n", frame_count_render, ms_per_frame); + SE_DEBUG("performance", "Render: {}fps, {}ms/frame", frame_count_render, ms_per_frame); + SE_DEBUG("performance", "-------------------------------"); frame_count_render = 0; last_frame_time_render += 1.0; } @@ -102,16 +102,16 @@ public: int main(int argc, char *argv[]) { se::Game game(640, 480, "SimpleEngine 3D OpenGL - Developer Testing", GLFW_OPENGL_CORE_PROFILE, 4, 4, false); + se::log::LoggerManager::set_level(spdlog::level::trace); + // Load core shaders from SimpleEngine resources se::gfx::shaders::Core3dShader core_shader; auto camera = std::make_shared(game.get_window(), core_shader, 70, glm::vec3(0, 0, 0)); - //game.add_event(camera); // Create a renderer auto renderer = std::make_shared(game.get_window(), core_shader, camera); renderer->initialize(); - //game.add_renderable(renderer); // Create a Scene and give it the renderer auto scene = std::make_shared(renderer, camera); @@ -143,6 +143,7 @@ int main(int argc, char *argv[]) { auto light = std::make_shared(core_shader, glm::vec3(0.f, 0.f, 0.f), glm::vec3(1.f, 1.f, 1.f)); game.add_event(light); + // TODO: Fix, for some reason it crashes auto fps_counter = std::make_shared(); game.add_renderable(fps_counter); @@ -150,7 +151,7 @@ int main(int argc, char *argv[]) { game.set_fps_limit(100); */ int res = game.run(); - std::cout << "Engine result: " << res << std::endl; + SE_CINFO("Engine result: {}", res); renderer->destroy(); scene->destroy(); diff --git a/include/simpleengine/gfx/renderer.h b/include/simpleengine/gfx/renderer.h index 436c95d..d0ef615 100644 --- a/include/simpleengine/gfx/renderer.h +++ b/include/simpleengine/gfx/renderer.h @@ -1,6 +1,7 @@ #pragma once #include "../camera.h" +#include "../log/logger.h" #include "shader.h" #include "../renderable.h" #include "rendering_type.h" @@ -30,7 +31,7 @@ namespace simpleengine::gfx { bool is_initialized = false; void check_if_initialized(); - + simpleengine::log::Logger logger; public: std::queue transparent_render_queue; std::queue other_render_queue; diff --git a/include/simpleengine/gfx/vao.h b/include/simpleengine/gfx/vao.h index ab7ddad..9264013 100644 --- a/include/simpleengine/gfx/vao.h +++ b/include/simpleengine/gfx/vao.h @@ -22,7 +22,7 @@ namespace simpleengine::gfx { } ~VAO() { - std::cout << "~vao(" << handle << ")" << std::endl; + // TODO: Anything to do here? } VAO& operator=(const VAO& other) { @@ -30,9 +30,6 @@ namespace simpleengine::gfx { handle = other.handle; } - - std::cout << "Copied " << handle << std::endl; - return *this; } diff --git a/include/simpleengine/gfx/vbo.h b/include/simpleengine/gfx/vbo.h index a24932a..eed30da 100644 --- a/include/simpleengine/gfx/vbo.h +++ b/include/simpleengine/gfx/vbo.h @@ -22,7 +22,7 @@ namespace simpleengine::gfx { } ~VBO() { - std::cout << "~vbo(" << handle << ")" << std::endl; + // TODO: Anything to do here? } static VBO init(GLint type, bool dynamic) { diff --git a/include/simpleengine/log/logger.h b/include/simpleengine/log/logger.h new file mode 100644 index 0000000..ff55f00 --- /dev/null +++ b/include/simpleengine/log/logger.h @@ -0,0 +1,385 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include +#include + +namespace simpleengine::log { + class Logger { + private: + std::shared_ptr inner; + public: + /** + * @brief Construct a new Logger object from a name + * + * This will first check if the spdlog logger exists, if it does not it will create a new `color_mt` logger + * + * @param name The name of the logger. + */ + Logger(std::string name) { + inner = spdlog::get(name); + + if (!inner) { + inner = spdlog::stderr_color_mt(name); + } + } + + /** + * @brief Construct a new Logger object using a spdlog::logger + * + * @param logger The inner spdlog::logger that this object will use + */ + Logger(std::shared_ptr logger) : inner(logger) { + + } + + /** + * @brief Get the inner spdlog logger object + * + * @return std::shared_ptr + */ + std::shared_ptr get_inner() { + return inner; + } + + /** + * @brief Set the log level. + * + * @param lvl The level to set the log to + */ + void set_level(spdlog::level::level_enum lvl) { + inner->set_level(lvl); + } + + /** + * @brief Log a message. + * + * @param lvl Level to log at + * @param msg The message to log + */ + void log(spdlog::level::level_enum lvl, spdlog::string_view_t msg) { + inner->log(lvl, msg); + } + + /** + * @brief Log a formatted message. + * + * @tparam Args + * @param lvl Level to log at + * @param fmt The string that will be formatted + * @param args The arguments to format into the message. + */ + template + void log(spdlog::level::level_enum lvl, fmt::format_string fmt, Args &&...args) + { + inner->log(lvl, fmt, std::forward(args)...); + } + + /** + * @brief Log a trace message. + * + * @tparam T + * @param msg The message that will be logged. + */ + template + void trace(const T &msg) { + log(spdlog::level::trace, msg); + } + + /** + * @brief Log a debug message. + * + * @tparam T + * @param msg The message that will be logged. + */ + template + void debug(const T &msg) { + log(spdlog::level::debug, msg); + } + + /** + * @brief Log an info message. + * + * @tparam T + * @param msg The message that will be logged. + */ + template + void info(const T &msg) { + log(spdlog::level::info, msg); + } + + /** + * @brief Log a warning message. + * + * @tparam T + * @param msg The message that will be logged. + */ + template + void warn(const T &msg) { + log(spdlog::level::warn, msg); + } + + /** + * @brief Log an error message. + * + * @tparam T + * @param msg The message that will be logged. + */ + template + void error(const T &msg) { + log(spdlog::level::err, msg); + } + + /** + * @brief Log a critical message. + * + * @tparam T + * @param msg The message that will be logged. + */ + template + void critical(const T &msg) { + log(spdlog::level::critical, msg); + } + + /** + * @brief Log a trace message. + * + * @tparam Args + * @param fmt String that will be formatted + * @param args Arguments to format into the message + */ + template + void trace(fmt::format_string fmt, Args &&... args) { + log(spdlog::level::trace, fmt, std::forward(args)...); + } + + /** + * @brief Log a debug message. + * + * @tparam Args + * @param fmt String that will be formatted + * @param args Arguments to format into the message + */ + template + void debug(fmt::format_string fmt, Args &&... args) { + log(spdlog::level::debug, fmt, std::forward(args)...); + } + + /** + * @brief Log an info message. + * + * @tparam Args + * @param fmt String that will be formatted + * @param args Arguments to format into the message + */ + template + void info(fmt::format_string fmt, Args &&... args) { + log(spdlog::level::info, fmt, std::forward(args)...); + } + + /** + * @brief Log a warning message. + * + * @tparam Args + * @param fmt String that will be formatted + * @param args Arguments to format into the message + */ + template + void warn(fmt::format_string fmt, Args &&... args) { + log(spdlog::level::warn, fmt, std::forward(args)...); + } + + /** + * @brief Log an error message. + * + * @tparam Args + * @param fmt String that will be formatted + * @param args Arguments to format into the message + */ + template + void error(fmt::format_string fmt, Args &&... args) { + log(spdlog::level::err, fmt, std::forward(args)...); + } + + /** + * @brief Log a critical message. + * + * @tparam Args + * @param fmt String that will be formatted + * @param args Arguments to format into the message + */ + template + void critical(fmt::format_string fmt, Args &&... args) { + log(spdlog::level::critical, fmt, std::forward(args)...); + } + }; + + class LoggerManager { + private: + static Logger core_logger; + public: + /** + * @brief Initialize the logger. + * + */ + static void init(); + + /** + * @brief Set the core log level. + * + * @param lvl + */ + static void set_level(spdlog::level::level_enum lvl); + + /** + * @brief Get the core logger. + * + * @return Logger& + */ + static Logger& get_core_logger(); + + /** + * @brief Create a new logger. + * + * @param name The name of the logger + * @return Logger + */ + static Logger create_logger(std::string name); + + /** + * @brief Get a logger using its name. + * + * @param name The name of the logger + * @return Logger + */ + static Logger get_logger(std::string name); + }; +} + +// Log macros + +/** + * @brief Log to a logger. + * + * @param logger_name The name of the logger to log to. + * @param level The level to log at. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_LOG(logger_name, level, message, ...) simpleengine::log::LoggerManager::get_logger(logger_name).log(level, fmt::format(message, ##__VA_ARGS__)); + +/** + * @brief Log to the core logger. + * + * @param level The level to log at. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CLOG(level, message, ...) simpleengine::log::LoggerManager::get_core_logger().log(level, fmt::format(message, ##__VA_ARGS__)); + +/** + * @brief Log a critical message to a logger. + * + * @param logger_name The name of the logger to log to. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CRIT(logger_name, message, ...) SE_LOG(logger_name, spdlog::level::critical, message, ##__VA_ARGS__); + +/** + * @brief Log a critical message to the core logger. + * + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CCRIT(message, ...) SE_CLOG(spdlog::level::critical, message, ##__VA_ARGS__); + +/** + * @brief Log an error message to a logger. + * + * @param logger_name The name of the logger to log to. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_ERROR(logger_name, message, ...) SE_LOG(logger_name, spdlog::level::err, message, ##__VA_ARGS__); + +/** + * @brief Log an error message to the core logger. + * + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CERROR(message, ...) SE_CLOG(spdlog::level::err, message, ##__VA_ARGS__); + +/** + * @brief Log a warning message to a logger. + * + * @param logger_name The name of the logger to log to. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_WARN(logger_name, message, ...) SE_LOG(logger_name, spdlog::level::warn, message, ##__VA_ARGS__); + +/** + * @brief Log a warning message to the core logger. + * + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CWARN(message, ...) SE_CLOG(spdlog::level::warn, message, ##__VA_ARGS__); + +/** + * @brief Log an info message to a logger. + * + * @param logger_name The name of the logger to log to. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_INFO(logger_name, message, ...) SE_LOG(logger_name, spdlog::level::info, message, ##__VA_ARGS__); + +/** + * @brief Log an info message to the core logger. + * + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CINFO(message, ...) SE_CLOG(spdlog::level::info, message, ##__VA_ARGS__); + +/** + * @brief Log a debug message to a logger. + * + * @param logger_name The name of the logger to log to. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_DEBUG(logger_name, message, ...) SE_LOG(logger_name, spdlog::level::debug, message, ##__VA_ARGS__); + +/** + * @brief Log a debug message to the core logger. + * + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CDEBUG(message, ...) SE_CLOG(spdlog::level::debug, message, ##__VA_ARGS__); + +/** + * @brief Log a trace message to a logger. + * + * @param logger_name The name of the logger to log to. + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_TRACE(logger_name, message, ...) SE_LOG(logger_name, spdlog::level::trace, message, ##__VA_ARGS__); + +/** + * @brief Log a trace message to the core logger. + * + * @param message The (to be) formatted message to log. + * @param ... The variables that will be formatted in the text. + */ +#define SE_CTRACE(message, ...) SE_CLOG(spdlog::level::trace, message, ##__VA_ARGS__); \ No newline at end of file diff --git a/include/simpleengine/shader_program.h b/include/simpleengine/shader_program.h index 120ddb2..5b7bc95 100644 --- a/include/simpleengine/shader_program.h +++ b/include/simpleengine/shader_program.h @@ -12,6 +12,7 @@ #include "event/event.h" #include "gfx/shader.h" +#include "log/logger.h" #include #include @@ -99,7 +100,7 @@ namespace simpleengine { glGetProgramiv(program, GL_LINK_STATUS, &success); if (!success) { - std::cerr << "Failed to link shader program!" << std::endl; + SE_CERROR("Failed to link shader program!"); throw gfx::ShaderException("Failed to link shader program!"); } diff --git a/shell.nix b/shell.nix index 47146ae..0412ece 100644 --- a/shell.nix +++ b/shell.nix @@ -12,5 +12,6 @@ pkgs.mkShell { glfw glm assimp + spdlog ]; } \ No newline at end of file diff --git a/src/game.cpp b/src/game.cpp index b5e6e12..35f8ca0 100644 --- a/src/game.cpp +++ b/src/game.cpp @@ -1,6 +1,7 @@ #include "game.h" #include "event/event.h" #include "renderable.h" +#include "log/logger.h" #include #include @@ -38,13 +39,15 @@ simpleengine::Game::Game(int w, int h, const std::string& window_name, const int glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { - std::cout << "Failed to initialize glew!" << std::endl; + SE_CERROR("Failed to initialize glew!"); glfwTerminate(); } update_enabled_vsync(); last_frame_time = std::chrono::high_resolution_clock::now(); + + log::LoggerManager::init(); } void simpleengine::Game::initialize(const int& gl_profile, const int& major_version, const int& minor_version, diff --git a/src/gfx/model.cpp b/src/gfx/model.cpp index 09d57c4..7077c02 100644 --- a/src/gfx/model.cpp +++ b/src/gfx/model.cpp @@ -3,6 +3,7 @@ #include "gfx/rendering_type.h" #include "gfx/texture.h" #include "vector.h" +#include "log/logger.h" #include #include @@ -38,7 +39,7 @@ namespace simpleengine::gfx { const aiScene *scene = importer.ReadFile(path, aiProcess_GenNormals | aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_FlipUVs); if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { - std::cout << "ERROR::ASSIMP::" << importer.GetErrorString() << std::endl; + SE_CERROR("Assimp error when attempting to import \"{}\"", importer.GetErrorString()); return; } @@ -117,8 +118,6 @@ namespace simpleengine::gfx { gfx::Material mat(default_textures, rendering_type); if (mesh->mMaterialIndex >= 0) { - std::cout << "TODO: Process model materials!" << std::endl; - std::unordered_map>> textures; aiMaterial *material = scene->mMaterials[mesh->mMaterialIndex]; @@ -217,7 +216,7 @@ namespace simpleengine::gfx { texture.path = texture_path; textures.emplace_back(std::make_shared(texture)); - std::cout << "Texture full path: " << full_path << ", texture_path: " << texture_path << std::endl; + SE_CDEBUG("Loaded texture! Full path: {}, relative path: {}", full_path, texture_path); } return textures; diff --git a/src/gfx/renderer.cpp b/src/gfx/renderer.cpp index eb3ad47..5056df2 100644 --- a/src/gfx/renderer.cpp +++ b/src/gfx/renderer.cpp @@ -23,7 +23,7 @@ namespace simpleengine::gfx { : rendering_type(rendering_type), rendering_mesh(&mesh), last_transform_mat(last_pos), transform_mat(position) {} Renderer::Renderer(GLFWwindow *window, gfx::Shader shader, std::shared_ptr camera) - : window(window), shader(shader), camera(camera)/* , transparent_render_queue(CameraDistanceComparator(camera)) */ {} + : window(window), shader(shader), camera(camera), logger(log::LoggerManager::create_logger("render")) {} Renderer::Renderer(GLFWwindow *window, GLuint shader_program, std::shared_ptr camera) : Renderer(window, gfx::Shader(shader_program), camera) {} @@ -31,13 +31,13 @@ namespace simpleengine::gfx { void debug_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) { - fprintf(stderr, "%s type = 0x%x, severity = 0x%x, message = %s\n", - (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""), type, severity, message); + SE_ERROR("render", "{} type = 0x%x, severity = 0x%x, message = {}", + (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""), type, severity, message); } void Renderer::check_if_initialized() { if (!is_initialized) { - std::cerr << "Renderer is not initialized!" << std::endl; + logger.critical("Renderer not initialized!"); // TODO: Automatic initialization throw std::runtime_error("Renderer is not initialized!"); } } @@ -107,7 +107,7 @@ namespace simpleengine::gfx { rendering_mesh->are_buffers_created = true; - std::cout << "Created render job buffers" << std::endl; + logger.debug("Created render job buffers"); } } @@ -126,11 +126,11 @@ namespace simpleengine::gfx { this->is_initialized = true; - std::cout << "Base Renderer initialized" << std::endl; + logger.debug("Base renderer initialized"); } void Renderer::destroy() { - std::cout << "Destroying renderer..." << std::endl; + logger.debug("Destroying renderer"); shader.delete_program(); } diff --git a/src/gfx/shader.cpp b/src/gfx/shader.cpp index b4e5b7d..ff16e5f 100644 --- a/src/gfx/shader.cpp +++ b/src/gfx/shader.cpp @@ -1,4 +1,5 @@ #include "gfx/shader.h" +#include "log/logger.h" #include #include @@ -40,7 +41,7 @@ namespace simpleengine::gfx { char log[512]; glGetShaderInfoLog(shd.shader, 512, NULL, log); - std::cerr << "Failed to load shader from source:" << std::endl << log << std::endl; + SE_CERROR("Failed to load shader from source:\n{}", log); throw ShaderException("Failed to compile shader!"); } @@ -63,7 +64,7 @@ namespace simpleengine::gfx { std::ifstream fstream(shader_path, std::ios::in); if (!fstream.is_open()) { - std::cerr << "Failed to open shader file: " << shader_path << std::endl; + SE_CERROR("Failed to open shader file: {}", shader_path); throw ShaderException("Failed to open shader file!"); } @@ -91,7 +92,7 @@ namespace simpleengine::gfx { glGetProgramiv(program, GL_LINK_STATUS, &success); if (!success) { - std::cerr << "Failed to link shader program!" << std::endl; + SE_CERROR("Failed to link shader program!"); throw ShaderException("Failed to link shader program!"); } } diff --git a/src/gfx/texture.cpp b/src/gfx/texture.cpp index 257c5d0..514c8b9 100644 --- a/src/gfx/texture.cpp +++ b/src/gfx/texture.cpp @@ -1,4 +1,6 @@ #include "gfx/texture.h" +#include "log/logger.h" + #include #define STB_IMAGE_IMPLEMENTATION @@ -27,10 +29,11 @@ namespace simpleengine::gfx { unsigned char*img_data = stbi_load(path, &width, &height, &channels, 0); if(!img_data) { const char* failure = stbi_failure_reason(); - std::cerr << "Failed to load texture! (" << failure << ")" << std::endl; + + SE_CERROR("Failed to load texture! Reason: {}", failure); throw std::runtime_error("Failed to load texture from memory!"); } - std::cout << "Loaded image with a width of " << width << "px, a height of " << height << "px and " << channels << " channels" << std::endl; + SE_CDEBUG("Loading image! Width = {}px, height = {}px, channel count = {}", width, height, channels); // Get the color type int color_format = 0; @@ -41,7 +44,7 @@ namespace simpleengine::gfx { } else if (channels == 4) { color_format = GL_RGBA; } else { - std::cerr << "Unknown texture color format with " << channels << " channels!" << std::endl; + SE_CERROR("Unknown texture color format with {} channels!", channels); throw std::runtime_error("Unknown texture color format!"); } @@ -79,10 +82,11 @@ namespace simpleengine::gfx { unsigned char* img_data = stbi_load_from_memory(buffer, buffer_length, &width, &height, &channels, 0); if(!img_data) { const char* failure = stbi_failure_reason(); - std::cerr << "Failed to load texture! (" << failure << ")" << std::endl; + + SE_CERROR("Failed to load texture! Reason: ", failure); throw std::runtime_error("Failed to load texture from memory!"); } - std::cout << "Loaded image with a width of " << width << "px, a height of " << height << "px and " << channels << " channels" << std::endl; + SE_CDEBUG("Loading image! Width = {}px, height = {}px, channel count = {}", width, height, channels); // Get the color type int color_format = 0; @@ -93,7 +97,7 @@ namespace simpleengine::gfx { } else if (channels == 4) { color_format = GL_RGBA; } else { - std::cerr << "Unknown texture color format with " << channels << " channels!" << std::endl; + SE_CERROR("Unknown texture color format with {} channels!", channels); throw std::runtime_error("Unknown texture color format!"); } diff --git a/src/log/logger.cpp b/src/log/logger.cpp new file mode 100644 index 0000000..80d5253 --- /dev/null +++ b/src/log/logger.cpp @@ -0,0 +1,30 @@ +#include "log/logger.h" +#include +#include + +namespace simpleengine::log { + Logger LoggerManager::core_logger = Logger("engine"); + + void LoggerManager::init() { + spdlog::set_pattern("[%T %D] [thread %t] [%n] [%l] %v"); + + spdlog::set_default_logger(core_logger.get_inner()); + set_level(spdlog::level::info); + } + + void LoggerManager::set_level(spdlog::level::level_enum lvl) { + spdlog::set_level(lvl); + } + + Logger& LoggerManager::get_core_logger() { + return core_logger; + } + + Logger LoggerManager::create_logger(std::string name) { + return Logger(name); + } + + Logger LoggerManager::get_logger(std::string name) { + return Logger(name); + } +} \ No newline at end of file diff --git a/src/scene.cpp b/src/scene.cpp index 2ecb694..e53d8ae 100644 --- a/src/scene.cpp +++ b/src/scene.cpp @@ -5,8 +5,10 @@ #include "ecs/component/rotating_component.h" #include "ecs/entity.h" #include "gfx/renderer.h" +#include "log/logger.h" #include +#include #include namespace simpleengine { @@ -60,7 +62,7 @@ namespace simpleengine { } void Scene::destroy() { - std::cout << "Destroying Scene..." << std::endl; + SE_DEBUG("scene", "Destroying Scene..."); registry.view().each([this](ModelComponent& model_component) { for (auto& mesh : model_component.model.meshes) { mesh.destroy();