PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

debug::Logger

Browse Source
This commit is contained in:
MihailRis 2024-04-04 18:19:19 +03:00
parent f298d6ef1d
commit 0c411cf227
16 changed files with 233 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/assets/AssetsLoader.cpp
View File

@ -8,12 +8,15 @@
#include "../constants.h"
#include "../data/dynamic.h"
#include "../debug/Logger.h"
#include "../files/files.h"
#include "../files/engine_paths.h"
#include "../content/Content.h"
#include "../content/ContentPack.h"
#include "../logic/scripting/scripting.h"
static debug::Logger logger("assets-loader");
AssetsLoader::AssetsLoader(Assets* assets, const ResPaths* paths)
: assets(assets), paths(paths)
{
@ -39,11 +42,10 @@ bool AssetsLoader::hasNext() const {
bool AssetsLoader::loadNext() {
const aloader_entry& entry = entries.front();
std::cout << " loading " << entry.filename << " as " << entry.alias << std::endl;
std::cout.flush();
logger.info() << "loading " << entry.filename << " as " << entry.alias;
auto found = loaders.find(entry.tag);
if (found == loaders.end()) {
std::cerr << "unknown asset tag " << static_cast<int>(entry.tag) << std::endl;
logger.error() << "unknown asset tag " << static_cast<int>(entry.tag);
return false;
}
aloader_func loader = found->second;

16
src/audio/AL/ALAudio.cpp
View File

@ -3,6 +3,10 @@
#include <string>
#include <iostream>
#include "../../debug/Logger.h"
static debug::Logger logger("al-audio");
using namespace audio;
ALSound::ALSound(ALAudio* al, uint buffer, std::shared_ptr<PCM> pcm, bool keepPCM)
@ -341,14 +345,14 @@ ALAudio::ALAudio(ALCdevice* device, ALCcontext* context)
alcGetIntegerv(device, ALC_ALL_ATTRIBUTES, size, &attrs[0]);
for (size_t i = 0; i < attrs.size(); ++i){
if (attrs[i] == ALC_MONO_SOURCES) {
std::cout << "AL: max mono sources: " << attrs[i+1] << std::endl;
logger.info() << "max mono sources: " << attrs[i+1];
maxSources = attrs[i+1];
}
}
auto devices = getAvailableDevices();
std::cout << "AL devices:" << std::endl;
logger.info() << "devices:";
for (auto& name : devices) {
std::cout << " " << name << std::endl;
logger.info() << " " << name;
}
}
@ -368,7 +372,7 @@ ALAudio::~ALAudio() {
AL_CHECK(alcMakeContextCurrent(context));
alcDestroyContext(context);
if (!alcCloseDevice(device)) {
std::cerr << "AL: device not closed!" << std::endl;
logger.error() << "device not closed!";
}
device = nullptr;
context = nullptr;
@ -395,7 +399,7 @@ ALAudio* ALAudio::create() {
return nullptr;
}
AL_CHECK();
std::cout << "AL: initialized" << std::endl;
logger.info() << "initialized";
return new ALAudio(device, context);
}
@ -406,7 +410,7 @@ uint ALAudio::getFreeSource(){
return source;
}
if (allsources.size() == maxSources){
std::cerr << "attempted to create new source, but limit is " << maxSources << std::endl;
logger.error() << "attempted to create new source, but limit is " << maxSources;
return 0;
}
ALuint id;

6
src/content/ContentLoader.cpp
View File

@ -7,6 +7,7 @@
#include <glm/glm.hpp>
#include "Content.h"
#include "../debug/Logger.h"
#include "../items/ItemDef.h"
#include "../util/listutil.h"
#include "../voxels/Block.h"
@ -21,6 +22,8 @@
namespace fs = std::filesystem;
static debug::Logger logger("content-loader");
ContentLoader::ContentLoader(ContentPack* pack) : pack(pack) {
}
@ -100,7 +103,6 @@ void ContentLoader::fixPackIndices() {
if (modified){
// rewrite modified json
std::cout << indexFile << std::endl;
files::write_json(indexFile, root.get());
}
}
@ -321,7 +323,7 @@ BlockMaterial ContentLoader::loadBlockMaterial(fs::path file, std::string full)
}
void ContentLoader::load(ContentBuilder& builder) {
std::cout << "-- loading pack [" << pack->id << "]" << std::endl;
logger.info() << "loading pack [" << pack->id << "]";
auto runtime = new ContentPackRuntime(*pack, scripting::create_pack_environment(*pack));
builder.add(runtime);

74
src/debug/Logger.cpp Normal file
View File

@ -0,0 +1,74 @@
#include "Logger.h"
#include <ctime>
#include <iomanip>
#include <chrono>
using namespace debug;
std::ofstream Logger::file;
std::mutex Logger::mutex;
std::string Logger::utcOffset = "";
unsigned Logger::moduleLen = 16;
LogMessage::~LogMessage() {
logger->log(level, ss.str());
}
Logger::Logger(std::string name) : name(name) {
}
void Logger::log(LogLevel level, const std::string& name, std::string message) {
using namespace std::chrono;
std::stringstream ss;
switch (level) {
case LogLevel::debug:
# ifdef NDEBUG
return;
# endif
ss << "[D]";
break;
case LogLevel::info:
ss << "[I]";
break;
case LogLevel::warning:
ss << "[W]";
break;
case LogLevel::error:
ss << "[E]";
break;
}
time_t tm = std::time(nullptr);
auto ms = duration_cast<milliseconds>(system_clock::now().time_since_epoch()) % 1000;
ss << " " << std::put_time(std::localtime(&tm), "%Y/%m/%d %T");
ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
ss << utcOffset << " (" << std::setfill(' ') << std::setw(moduleLen) << name << ") ";
ss << message;
{
std::lock_guard<std::mutex> lock(mutex);
auto string = ss.str();
if (file.good()) {
file << string << '\n';
}
std::cout << string << std::endl;
}
}
void Logger::init(const std::string& filename) {
file.open(filename);
time_t tm = std::time(nullptr);
std::stringstream ss;
ss << std::put_time(std::localtime(&tm), "%z");
utcOffset = ss.str();
}
void Logger::flush() {
std::lock_guard<std::mutex> lock(mutex);
file.flush();
}
void Logger::log(LogLevel level, std::string message) {
log(level, name, message);
}

66
src/debug/Logger.h Normal file
View File

@ -0,0 +1,66 @@
#ifndef DEBUG_LOGGER_H_
#define DEBUG_LOGGER_H_
#include <sstream>
#include <fstream>
#include <iostream>
#include <mutex>
namespace debug {
enum class LogLevel {
debug, info, warning, error
};
class Logger;
class LogMessage {
Logger* logger;
LogLevel level;
std::stringstream ss;
public:
LogMessage(Logger* logger, LogLevel level) : logger(logger), level(level) {}
~LogMessage();
template<class T>
LogMessage& operator<<(const T& x) {
ss << x;
return *this;
}
};
class Logger {
static std::mutex mutex;
static std::string utcOffset;
static std::ofstream file;
static unsigned moduleLen;
std::string name;
static void log(LogLevel level, const std::string& name, std::string message);
public:
static void init(const std::string& filename);
static void flush();
Logger(std::string name);
void log(LogLevel level, std::string message);
LogMessage debug() {
return LogMessage(this, LogLevel::debug);
}
LogMessage info() {
return LogMessage(this, LogLevel::info);
}
LogMessage error() {
return LogMessage(this, LogLevel::error);
}
LogMessage warning() {
return LogMessage(this, LogLevel::warning);
}
};
}
#endif // DEBUG_LOGGER_H_

15
src/engine.cpp
View File

@ -44,6 +44,10 @@
#include <unordered_set>
#include <functional>
#include "debug/Logger.h"
static debug::Logger logger("engine");
namespace fs = std::filesystem;
void addWorldGenerators() {
@ -80,7 +84,8 @@ Engine::Engine(EngineSettings& settings, EnginePaths* paths)
});
auto resdir = paths->getResources();
std::cout << "-- loading assets" << std::endl;
logger.info() << "loading assets";
std::vector<fs::path> roots {resdir};
resPaths = std::make_unique<ResPaths>(resdir, roots);
@ -150,7 +155,7 @@ void Engine::mainloop() {
Batch2D batch(1024);
lastTime = Window::time();
std::cout << "-- initialized" << std::endl;
logger.info() << "initialized";
while (!Window::isShouldClose()){
assert(screen != nullptr);
updateTimers();
@ -190,7 +195,7 @@ void Engine::processPostRunnables() {
}
Engine::~Engine() {
std::cout << "-- shutting down" << std::endl;
logger.info() << "shutting down";
if (screen) {
screen->onEngineShutdown();
}
@ -200,7 +205,7 @@ Engine::~Engine() {
audio::close();
scripting::close();
Window::terminate();
std::cout << "-- engine finished" << std::endl;
logger.info() << "engine finished";
}
inline const std::string checkPacks(
@ -257,7 +262,7 @@ void Engine::loadContent() {
langs::setup(resdir, langs::current->getId(), contentPacks);
std::cout << "-- loading assets" << std::endl;
logger.info() << "loading assets";
auto new_assets = std::make_unique<Assets>();
Shader::preprocessor->setPaths(resPaths.get());

2
src/frontend/screens.cpp
View File

@ -14,7 +14,7 @@
#include "../graphics/ui/GUI.h"
#include "../logic/ChunksController.h"
#include "../logic/LevelController.h"
#include "../logic/scripting/scripting_frontend.h"
#include "../logic/scripting/scripting_hud.h"
#include "../logic/scripting/scripting.h"
#include "../objects/Player.h"
#include "../physics/Hitbox.h"

16
src/graphics/render/ChunksRenderer.cpp
View File

@ -1,5 +1,6 @@
#include "ChunksRenderer.h"
#include "../../debug/Logger.h"
#include "../../graphics/core/Mesh.h"
#include "BlocksRenderer.h"
#include "../../voxels/Chunk.h"
@ -9,6 +10,8 @@
#include <glm/glm.hpp>
#include <glm/ext.hpp>
static debug::Logger logger("chunks-render");
ChunksRenderer::ChunksRenderer(Level* level, const ContentGfxCache* cache, const EngineSettings& settings)
: level(level), cache(cache), settings(settings) {
const int MAX_FULL_CUBES = 3000;
@ -21,7 +24,7 @@ ChunksRenderer::ChunksRenderer(Level* level, const ContentGfxCache* cache, const
threads.emplace_back(&ChunksRenderer::threadLoop, this, i);
workersBlocked.emplace_back();
}
std::cout << "created " << num_threads << " chunks rendering threads" << std::endl;
logger.info() << "created " << num_threads << " rendering threads";
}
ChunksRenderer::~ChunksRenderer() {
@ -32,7 +35,7 @@ ChunksRenderer::~ChunksRenderer() {
resultsMutex.lock();
while (!results.empty()) {
mesh_entry entry = results.front();
Result entry = results.front();
results.pop();
entry.locked = false;
entry.variable.notify_all();
@ -70,7 +73,7 @@ void ChunksRenderer::threadLoop(int index) {
process(chunk, renderer);
{
resultsMutex.lock();
results.push(mesh_entry {renderer, variable, index, locked, glm::ivec2(chunk->x, chunk->z)});
results.push(Result {variable, index, locked, {renderer, glm::ivec2(chunk->x, chunk->z)}});
locked = true;
resultsMutex.unlock();
}
@ -139,10 +142,11 @@ std::shared_ptr<Mesh> ChunksRenderer::get(Chunk* chunk) {
void ChunksRenderer::update() {
resultsMutex.lock();
while (!results.empty()) {
mesh_entry entry = results.front();
Result entry = results.front();
mesh_entry mesh = entry.entry;
results.pop();
meshes[entry.key] = std::shared_ptr<Mesh>(entry.renderer.createMesh());
inwork.erase(entry.key);
meshes[mesh.key] = std::shared_ptr<Mesh>(mesh.renderer.createMesh());
inwork.erase(mesh.key);
entry.locked = false;
entry.variable.notify_all();
}

8
src/graphics/render/ChunksRenderer.h
View File

@ -22,10 +22,14 @@ class ContentGfxCache;
struct mesh_entry {
BlocksRenderer& renderer;
glm::ivec2 key;
};
struct Result {
std::condition_variable& variable;
int workerIndex;
bool& locked;
glm::ivec2 key;
mesh_entry entry;
};
class ChunksRenderer {
@ -35,7 +39,7 @@ class ChunksRenderer {
std::unordered_map<glm::ivec2, bool> inwork;
std::vector<std::thread> threads;
std::queue<mesh_entry> results;
std::queue<Result> results;
std::mutex resultsMutex;
std::queue<std::shared_ptr<Chunk>> jobs;

5
src/logic/LevelController.cpp
View File

@ -1,4 +1,5 @@
#include "LevelController.h"
#include "../debug/Logger.h"
#include "../world/Level.h"
#include "../world/World.h"
#include "../physics/Hitbox.h"
@ -6,7 +7,7 @@
#include "scripting/scripting.h"
#include "../interfaces/Object.h"
#include <iostream>
static debug::Logger logger("level-control");
LevelController::LevelController(EngineSettings& settings, Level* level)
: settings(settings), level(level),
@ -43,7 +44,7 @@ void LevelController::update(float delta, bool input, bool pause) {
}
void LevelController::saveWorld() {
std::cout << "-- writing world" << std::endl;
logger.info() << "writing world";
scripting::on_world_save();
level->getWorld()->write(level.get());
}

7
src/logic/scripting/lua/LuaState.cpp
View File

@ -4,8 +4,11 @@
#include <iostream>
#include "lua_util.h"
#include "api_lua.h"
#include "../../../debug/Logger.h"
#include "../../../util/stringutil.h"
static debug::Logger logger("lua-state");
lua::luaerror::luaerror(const std::string& message) : std::runtime_error(message) {
}
@ -19,8 +22,8 @@ void lua::LuaState::removeLibFuncs(const char* libname, const char* funcs[]) {
}
lua::LuaState::LuaState() {
std::cout << LUA_VERSION << std::endl;
std::cout << LUAJIT_VERSION << std::endl;
logger.info() << LUA_VERSION;
logger.info() << LUAJIT_VERSION;
L = luaL_newstate();
if (L == nullptr) {

11
src/logic/scripting/scripting.cpp
View File

@ -3,6 +3,7 @@
#include <iostream>
#include <stdexcept>
#include "../../debug/Logger.h"
#include "../../content/ContentPack.h"
#include "../../files/engine_paths.h"
#include "../../files/files.h"
@ -26,6 +27,8 @@ namespace scripting {
extern lua::LuaState* state;
}
static debug::Logger logger("scripting");
Engine* scripting::engine = nullptr;
lua::LuaState* scripting::state = nullptr;
Level* scripting::level = nullptr;
@ -284,7 +287,7 @@ bool scripting::emit_event(const std::string &name, std::function<int(lua::LuaSt
void scripting::load_block_script(int env, std::string prefix, fs::path file, block_funcs_set& funcsset) {
std::string src = files::read_string(file);
std::cout << "loading script " << file.u8string() << std::endl;
logger.info() << "script (block) " << file.u8string();
state->execute(env, src, file.u8string());
funcsset.init = register_event(env, "init", prefix+".init");
funcsset.update = register_event(env, "on_update", prefix+".update");
@ -297,7 +300,7 @@ void scripting::load_block_script(int env, std::string prefix, fs::path file, bl
void scripting::load_item_script(int env, std::string prefix, fs::path file, item_funcs_set& funcsset) {
std::string src = files::read_string(file);
std::cout << "loading script " << file.u8string() << std::endl;
logger.info() << "script (item) " << file.u8string();
state->execute(env, src, file.u8string());
funcsset.init = register_event(env, "init", prefix+".init");
@ -308,7 +311,7 @@ void scripting::load_item_script(int env, std::string prefix, fs::path file, ite
void scripting::load_world_script(int env, std::string prefix, fs::path file) {
std::string src = files::read_string(file);
std::cout << "loading script " << file.u8string() << std::endl;
logger.info() << "loading world script for " << prefix;
state->loadbuffer(env, src, file.u8string());
state->callNoThrow(0);
@ -322,7 +325,7 @@ void scripting::load_world_script(int env, std::string prefix, fs::path file) {
void scripting::load_layout_script(int env, std::string prefix, fs::path file, uidocscript& script) {
std::string src = files::read_string(file);
std::cout << "loading script " << file.u8string() << std::endl;
logger.info() << "loading script " << file.u8string();
script.environment = env;
state->loadbuffer(env, src, file.u8string());

7
src/logic/scripting/scripting_frontend.cpp → src/logic/scripting/scripting_hud.cpp
View File

@ -1,9 +1,10 @@
#include "scripting_frontend.h"
#include "scripting_hud.h"
#include "scripting.h"
#include "lua/api_lua.h"
#include "lua/LuaState.h"
#include "../../debug/Logger.h"
#include "../../frontend/hud.h"
#include "../../objects/Player.h"
#include "../../files/files.h"
@ -15,6 +16,8 @@ namespace scripting {
extern lua::LuaState* state;
}
static debug::Logger logger("scripting-hud");
Hud* scripting::hud = nullptr;
void scripting::on_frontend_init(Hud* hud) {
@ -41,7 +44,7 @@ void scripting::on_frontend_close() {
void scripting::load_hud_script(int env, std::string packid, fs::path file) {
std::string src = files::read_string(file);
std::cout << "loading script " << file.u8string() << std::endl;
logger.info() << "loading script " << file.u8string();
state->loadbuffer(env, src, file.u8string());
state->callNoThrow(0);

6
src/logic/scripting/scripting_frontend.h → src/logic/scripting/scripting_hud.h
View File

@ -1,5 +1,5 @@
#ifndef LOGIC_SCRIPTING_SCRIPTING_FRONTEND_H_
#define LOGIC_SCRIPTING_SCRIPTING_FRONTEND_H_
#ifndef LOGIC_SCRIPTING_SCRIPTING_HUD_H_
#define LOGIC_SCRIPTING_SCRIPTING_HUD_H_
#include <string>
#include <filesystem>
@ -23,4 +23,4 @@ namespace scripting {
void load_hud_script(int env, std::string packid, fs::path file);
}
#endif // LOGIC_SCRIPTING_SCRIPTING_FRONTEND_H_
#endif // LOGIC_SCRIPTING_SCRIPTING_HUD_H_

19
src/voxel_engine.cpp
View File

@ -13,13 +13,18 @@
#include "files/engine_paths.h"
#include "util/platform.h"
#include "util/command_line.h"
#include "debug/Logger.h"
#define SETTINGS_FILE "settings.toml"
#define CONTROLS_FILE "controls.json"
static debug::Logger logger("main");
namespace fs = std::filesystem;
int main(int argc, char** argv) {
debug::Logger::init("latest.log");
EnginePaths paths;
if (!parse_cmdline(argc, argv, paths))
return EXIT_SUCCESS;
@ -33,7 +38,7 @@ int main(int argc, char** argv) {
fs::path settings_file = userfiles/fs::path(SETTINGS_FILE);
fs::path controls_file = userfiles/fs::path(CONTROLS_FILE);
if (fs::is_regular_file(settings_file)) {
std::cout << "-- loading settings" << std::endl;
logger.info() << "loading settings";
std::string text = files::read_string(settings_file);
toml::Reader reader(wrapper.get(), settings_file.string(), text);
reader.read();
@ -41,19 +46,23 @@ int main(int argc, char** argv) {
corecontent::setup_bindings();
Engine engine(settings, &paths);
if (fs::is_regular_file(controls_file)) {
std::cout << "-- loading controls" << std::endl;
logger.info() << "loading controls";
std::string text = files::read_string(controls_file);
load_controls(controls_file.string(), text);
}
engine.mainloop();
std::cout << "-- saving settings" << std::endl;
logger.info() << "saving settings";
files::write_string(settings_file, wrapper->write());
files::write_string(controls_file, write_controls());
}
catch (const initialize_error& err) {
std::cerr << "could not to initialize engine" << std::endl;
std::cerr << err.what() << std::endl;
logger.error() << "could not to initialize engine\n" << err.what();
}
catch (const std::exception& err) {
logger.error() << "uncaught exception: " << err.what();
debug::Logger::flush();
throw;
}
return EXIT_SUCCESS;
}

18
src/window/Window.cpp
View File

@ -1,11 +1,14 @@
#include <iostream>
#include "Window.h"
#include "Events.h"
#include "../debug/Logger.h"
#include "../graphics/core/ImageData.h"
#include <GL/glew.h>
#include <GLFW/glfw3.h>
static debug::Logger logger("window");
GLFWwindow* Window::window = nullptr;
DisplaySettings* Window::settings = nullptr;
std::stack<glm::vec4> Window::scissorStack;
@ -106,7 +109,7 @@ int Window::initialize(DisplaySettings& settings){
glfwSetErrorCallback(error_callback);
if (glfwInit() == GLFW_FALSE) {
std::cerr << "Failed to initialize GLFW" << std::endl;
logger.error() << "failed to initialize GLFW";
return -1;
}
@ -124,7 +127,7 @@ int Window::initialize(DisplaySettings& settings){
window = glfwCreateWindow(width, height, settings.title.c_str(), nullptr, nullptr);
if (window == nullptr){
std::cerr << "Failed to create GLFW Window" << std::endl;
logger.error() << "failed to create GLFW window";
glfwTerminate();
return -1;
}
@ -133,8 +136,7 @@ int Window::initialize(DisplaySettings& settings){
glewExperimental = GL_TRUE;
GLenum glewErr = glewInit();
if (glewErr != GLEW_OK){
std::cerr << "Failed to initialize GLEW: " << std::endl;
std::cerr << glewGetErrorString(glewErr) << std::endl;
logger.error() << "failed to initialize GLEW:\n" << glewGetErrorString(glewErr);
return -1;
}
@ -157,9 +159,9 @@ int Window::initialize(DisplaySettings& settings){
glfwSwapInterval(settings.swapInterval);
const GLubyte* vendor = glGetString(GL_VENDOR);
const GLubyte* renderer = glGetString(GL_RENDERER);
std::cout << "GL Vendor: " << (char*)vendor << std::endl;
std::cout << "GL Renderer: " << (char*)renderer << std::endl;
std::cout << "GLFW: " << glfwGetVersionString() << std::endl;
logger.info() << "GL Vendor: " << (char*)vendor;
logger.info() << "GL Renderer: " << (char*)renderer;
logger.info() << "GLFW: " << glfwGetVersionString();
return 0;
}
@ -234,7 +236,7 @@ void Window::pushScissor(glm::vec4 area) {
void Window::popScissor() {
if (scissorStack.empty()) {
std::cerr << "warning: extra Window::popScissor call" << std::endl;
logger.warning() << "extra Window::popScissor call";
return;
}
glm::vec4 area = scissorStack.top();