120 lines
5.1 KiB
C++
120 lines
5.1 KiB
C++
//
|
|
// Created by illyum on 9/15/2024.
|
|
//
|
|
|
|
#include <ICEngine.hpp>
|
|
#include <fstream>
|
|
#include <src/platform/Platform.hpp>
|
|
|
|
void ShowLogger();
|
|
|
|
void CustomTermHandler(const std::string &message);
|
|
|
|
int main() {
|
|
// You can set a custom termination handler/function.
|
|
// Make sure you do this before you start the application!!!
|
|
ICEngine::ICEApplication::SetTerminationHandler(CustomTermHandler);
|
|
// This is optional
|
|
|
|
// Logger Information
|
|
ShowLogger();
|
|
|
|
ICEngine::StartApplication();
|
|
return 0;
|
|
}
|
|
|
|
|
|
void ShowLogger() {
|
|
// The logger needs to be initialized before you can use it.
|
|
// This will be done by the engine, NEVER the user.
|
|
ICEngine::Log::Init();
|
|
|
|
// Before using the logger macros, you may want to configure logging options such as log levels and output streams.
|
|
// By default, the logger outputs to std::cout, but you can add more streams (e.g., files) or set the log level as needed.
|
|
|
|
// Logging Levels:
|
|
// - OFF
|
|
// - TRACE
|
|
// - DEBUG
|
|
// - WARN
|
|
// - ERROR
|
|
// - CRITICAL
|
|
// - FATAL
|
|
ICEngine::Log::GetCoreLogger()->SetLevel(ICEngine::TRACE);
|
|
ICEngine::Log::GetAppLogger()->SetLevel(ICEngine::TRACE);
|
|
|
|
// You can have multiple log streams, ie console + file etc
|
|
// You do not need to have the same streams for each logger
|
|
#include <fstream>
|
|
// Create file streams and transfer ownership to the logger
|
|
// You need to create a unique pointer, because the logger will
|
|
// take ownership of the streams and clean them up when the app
|
|
// is complete
|
|
ICEngine::Log::GetCoreLogger()->AddSink(std::make_shared<ICEngine::FileSink>("core_logs.txt"));
|
|
ICEngine::Log::GetCoreLogger()->AddSink(std::make_shared<ICEngine::ConsoleSink>());
|
|
|
|
ICEngine::Log::GetAppLogger()->AddSink(std::make_shared<ICEngine::FileSink>("app_logs.txt"));
|
|
ICEngine::Log::GetAppLogger()->AddSink(std::make_shared<ICEngine::ConsoleSink>());
|
|
|
|
// You can log multiple different types with formatting
|
|
int age = 30;
|
|
std::string module = "Network";
|
|
|
|
// CORE logger is intended for internal engine or core-level logging
|
|
// In most cases, you won't need to use CORE logging in game/application code,
|
|
// but it's available for engine-level diagnostics if necessary
|
|
CORE_LOG_TRACE("Initializing {} with age {}", module, age);
|
|
// Logs a trace-level message, useful for very detailed information
|
|
CORE_LOG_DEBUG("This is an example of a debug message");
|
|
// Logs a debug message, typically used for debugging purposes
|
|
CORE_LOG_WARN("This is an example of a warn message");
|
|
// Logs a warning, indicating a non-critical issue that should be investigated
|
|
CORE_LOG_ERROR("This is an example of an error message");
|
|
// Logs an error, signaling that something has gone wrong but the engine can still run
|
|
CORE_LOG_CRITICAL("This is an example of a critical message");
|
|
// Logs a critical issue, often indicating a major problem in the core system that needs immediate attention.
|
|
// CORE_LOG_FATAL: Logs a fatal error that crashes the application. Fatal errors in the core usually lead to dumping information into crash logs
|
|
// and stopping the program. Use with extreme caution and only in situations where the application can't recover
|
|
// CORE_LOG_FATAL("This is an example of a fatal message");
|
|
|
|
|
|
// These macros are designed for logging from your game or application code
|
|
// They allow you to monitor application flow, errors, and warnings from the perspective of the game logic or app layer
|
|
LOG_TRACE("App took longer to respond than expected: {} seconds", 2.34);
|
|
// Logs a trace message, ideal for fine-grained, verbose debugging details
|
|
LOG_DEBUG("This is an example of a debug message");
|
|
// Logs a debug message, typically used to help trace the execution during development
|
|
LOG_WARN("This is an example of a warn message");
|
|
// Logs a warning, indicating something unexpected happened, but the application can continue running
|
|
LOG_ERROR("This is an example of an error message");
|
|
// Logs an error, signaling that an issue occurred that may require attention but is not catastrophic
|
|
LOG_CRITICAL("This is an example of a critical message");
|
|
// Logs a critical message, suggesting something very wrong happened, but the program may still attempt to run
|
|
|
|
// LOG_FATAL: Logs a fatal error in the application layer. This will trigger the Fatal Handler, which you can override
|
|
// The Fatal Handler provides a mechanism for handling unrecoverable errors gracefully, allowing you to define how the application reacts to fatal crashes
|
|
// LOG_FATAL("This is an example of log fatal crash!");
|
|
}
|
|
|
|
void CustomTermHandler(const std::string &message) {
|
|
// Perform any other task here, like showing a popup warning indicating something crashed
|
|
Platform::ShowPopup("Demo App", message);
|
|
// You don't have to specify a title, it will default to ICEngine
|
|
// Platform::ShowPopup(message);
|
|
std::exit(EXIT_FAILURE); // Terminate here if you need to
|
|
}
|
|
|
|
|
|
class DemoApp : public ICEngine::ICEApplication {
|
|
public:
|
|
void Run() override {
|
|
LOG_TRACE("Running demo app!");
|
|
CORE_LOG_FATAL("Fatal error"); // This will terminate the application
|
|
LOG_TRACE("Demo app completed successfully!"); // Therefore this will not run
|
|
}
|
|
};
|
|
|
|
ICEngine::ICEApplication *ICEngine::CreateICEApplication() {
|
|
return new DemoApp();
|
|
}
|