SeanOMik
/
SimpleEngine
mirror of https://github.com/SeanOMik/SimpleEngine.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #8 from SeanOMik/feature/logging 

Create a logger
This commit is contained in:
SeanOMik 2022-11-20 12:56:58 -05:00 committed by GitHub
parent 8493e2aa86 118fce50fa
commit 7a7c80af2e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 473 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-tidy
View File

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

8
CMakeLists.txt
View File

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

21
examples/dev_testing/src/main.cpp
View File

@ -21,6 +21,7 @@
#include <simpleengine/scene.h>
#include <simpleengine/shader_program.h>
#include <simpleengine/vertex.h>
#include <simpleengine/log/logger.h>
#include <assimp/material.h>
#include <glm/ext/matrix_clip_space.hpp>
@ -29,6 +30,7 @@
#include <chrono>
#include <iostream>
#include <memory>
#include <spdlog/common.h>
#include <sstream>
#include <stdint.h>
@ -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<se::Camera>(game.get_window(), core_shader, 70, glm::vec3(0, 0, 0));
//game.add_event(camera);
// Create a renderer
auto renderer = std::make_shared<se::gfx::Renderer>(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<se::Scene>(renderer, camera);
@ -143,6 +143,7 @@ int main(int argc, char *argv[]) {
auto light = std::make_shared<se::gfx::Light>(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<FPSCounterEvent>();
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();

3
include/simpleengine/gfx/renderer.h
View File

@ -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<RenderingJob> transparent_render_queue;
std::queue<RenderingJob> other_render_queue;

5
include/simpleengine/gfx/vao.h
View File

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

2
include/simpleengine/gfx/vbo.h
View File

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

385
include/simpleengine/log/logger.h Normal file
View File

@ -0,0 +1,385 @@
#pragma once
#include <memory>
#include <string>
#include <unordered_map>
#include <spdlog/logger.h>
#include <spdlog/spdlog.h>
#include <spdlog/common.h>
#include <spdlog/sinks/stdout_color_sinks.h>
namespace simpleengine::log {
class Logger {
private:
std::shared_ptr<spdlog::logger> 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<spdlog::logger> logger) : inner(logger) {
}
/**
* @brief Get the inner spdlog logger object
*
* @return std::shared_ptr<spdlog::logger>
*/
std::shared_ptr<spdlog::logger> 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<typename... Args>
void log(spdlog::level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args)
{
inner->log(lvl, fmt, std::forward<Args>(args)...);
}
/**
* @brief Log a trace message.
*
* @tparam T
* @param msg The message that will be logged.
*/
template<typename T>
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<typename T>
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<typename T>
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<typename T>
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<typename T>
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<typename T>
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<typename... Args>
void trace(fmt::format_string<Args...> fmt, Args &&... args) {
log(spdlog::level::trace, fmt, std::forward<Args>(args)...);
}
/**
* @brief Log a debug message.
*
* @tparam Args
* @param fmt String that will be formatted
* @param args Arguments to format into the message
*/
template<typename... Args>
void debug(fmt::format_string<Args...> fmt, Args &&... args) {
log(spdlog::level::debug, fmt, std::forward<Args>(args)...);
}
/**
* @brief Log an info message.
*
* @tparam Args
* @param fmt String that will be formatted
* @param args Arguments to format into the message
*/
template<typename... Args>
void info(fmt::format_string<Args...> fmt, Args &&... args) {
log(spdlog::level::info, fmt, std::forward<Args>(args)...);
}
/**
* @brief Log a warning message.
*
* @tparam Args
* @param fmt String that will be formatted
* @param args Arguments to format into the message
*/
template<typename... Args>
void warn(fmt::format_string<Args...> fmt, Args &&... args) {
log(spdlog::level::warn, fmt, std::forward<Args>(args)...);
}
/**
* @brief Log an error message.
*
* @tparam Args
* @param fmt String that will be formatted
* @param args Arguments to format into the message
*/
template<typename... Args>
void error(fmt::format_string<Args...> fmt, Args &&... args) {
log(spdlog::level::err, fmt, std::forward<Args>(args)...);
}
/**
* @brief Log a critical message.
*
* @tparam Args
* @param fmt String that will be formatted
* @param args Arguments to format into the message
*/
template<typename... Args>
void critical(fmt::format_string<Args...> fmt, Args &&... args) {
log(spdlog::level::critical, fmt, std::forward<Args>(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__);

3
include/simpleengine/shader_program.h
View File

@ -12,6 +12,7 @@
#include "event/event.h"
#include "gfx/shader.h"
#include "log/logger.h"
#include <exception>
#include <fstream>
@ -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!");
}

1
shell.nix
View File

@ -12,5 +12,6 @@ pkgs.mkShell {
glfw
glm
assimp
spdlog
];
}

5
src/game.cpp
View File

@ -1,6 +1,7 @@
#include "game.h"
#include "event/event.h"
#include "renderable.h"
#include "log/logger.h"
#include <chrono>
#include <iostream>
@ -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,

7
src/gfx/model.cpp
View File

@ -3,6 +3,7 @@
#include "gfx/rendering_type.h"
#include "gfx/texture.h"
#include "vector.h"
#include "log/logger.h"
#include <assimp/Importer.hpp>
#include <assimp/material.h>
@ -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<aiTextureType, std::vector<std::shared_ptr<Texture>>> 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>(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;

14
src/gfx/renderer.cpp
View File

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

7
src/gfx/shader.cpp
View File

@ -1,4 +1,5 @@
#include "gfx/shader.h"
#include "log/logger.h"
#include <glm/fwd.hpp>
#include <glm/gtc/type_ptr.hpp>
@ -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!");
}
}

16
src/gfx/texture.cpp
View File

@ -1,4 +1,6 @@
#include "gfx/texture.h"
#include "log/logger.h"
#include <stdexcept>
#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!");
}

30
src/log/logger.cpp Normal file
View File

@ -0,0 +1,30 @@
#include "log/logger.h"
#include <spdlog/common.h>
#include <spdlog/spdlog.h>
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);
}
}

4
src/scene.cpp
View File

@ -5,8 +5,10 @@
#include "ecs/component/rotating_component.h"
#include "ecs/entity.h"
#include "gfx/renderer.h"
#include "log/logger.h"
#include <glm/gtx/string_cast.hpp>
#include <spdlog/common.h>
#include <stdexcept>
namespace simpleengine {
@ -60,7 +62,7 @@ namespace simpleengine {
}
void Scene::destroy() {
std::cout << "Destroying Scene..." << std::endl;
SE_DEBUG("scene", "Destroying Scene...");
registry.view<ModelComponent>().each([this](ModelComponent& model_component) {
for (auto& mesh : model_component.model.meshes) {
mesh.destroy();