Pantyhose-X
/
vengi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

METRIC: refactored metric module use

Martin Gerhardy 2018-01-30 22:38:51 +01:00
parent 5f9bc4afa0
commit 3c1513f676
81 changed files with 370 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/client/Client.cpp
View File

@ -38,9 +38,9 @@
_moveMask &= ~network::MoveDirection::flag; \
}).setHelp("Character movement");
Client::Client(const video::MeshPoolPtr& meshPool, const network::ClientNetworkPtr& network, const voxel::WorldPtr& world, const network::ClientMessageSenderPtr& messageSender,
Client::Client(const metric::MetricPtr& metric, const video::MeshPoolPtr& meshPool, const network::ClientNetworkPtr& network, const voxel::WorldPtr& world, const network::ClientMessageSenderPtr& messageSender,
const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const io::FilesystemPtr& filesystem) :
Super(filesystem, eventBus, timeProvider, 17816), _camera(), _meshPool(meshPool), _network(network), _world(world), _messageSender(messageSender),
Super(metric, filesystem, eventBus, timeProvider), _camera(), _meshPool(meshPool), _network(network), _world(world), _messageSender(messageSender),
_worldRenderer(world), _waiting(this) {
_world->setClientData(true);
init(ORGANISATION, "client");
@ -380,6 +380,7 @@ int main(int argc, char *argv[]) {
const network::ProtocolHandlerRegistryPtr& protocolHandlerRegistry = std::make_shared<network::ProtocolHandlerRegistry>();
const network::ClientNetworkPtr& network = std::make_shared<network::ClientNetwork>(protocolHandlerRegistry, eventBus);
const network::ClientMessageSenderPtr& messageSender = std::make_shared<network::ClientMessageSender>(network);
Client app(meshPool, network, world, messageSender, eventBus, timeProvider, filesystem);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
Client app(metric, meshPool, network, world, messageSender, eventBus, timeProvider, filesystem);
return app.startMainLoop(argc, argv);
}

5
src/client/Client.h
View File

@ -62,8 +62,9 @@ protected:
void handleLogin();
int renderMap(video::Shader& shader, const voxel::WorldPtr& world, const glm::mat4& view, float aspect);
public:
Client(const video::MeshPoolPtr& meshPool, const network::ClientNetworkPtr& network, const voxel::WorldPtr& world, const network::ClientMessageSenderPtr& messageSender,
const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const io::FilesystemPtr& filesystem);
Client(const metric::MetricPtr& metric, const video::MeshPoolPtr& meshPool, const network::ClientNetworkPtr& network, const voxel::WorldPtr& world,
const network::ClientMessageSenderPtr& messageSender, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider,
const io::FilesystemPtr& filesystem);
~Client();
core::AppState onConstruct() override;

8
src/modules/backend/loop/ServerLoop.cpp
View File

@ -73,18 +73,18 @@ void ServerLoop::signalCallback(uv_signal_t* handle, int signum) {
void ServerLoop::onIdle(uv_idle_t* handle) {
ServerLoop* loop = (ServerLoop*)handle->data;
metric::Metric& metric = loop->_metricMgr->metric();
const metric::MetricPtr& metric = loop->_metricMgr->metric();
const core::App* app = core::App::getInstance();
const int deltaFrame = app->deltaFrame();
constexpr int delta = 10;
if (std::abs(deltaFrame - loop->_lastDeltaFrame) > delta) {
metric.timing("frame.delta", app->deltaFrame());
metric->timing("frame.delta", app->deltaFrame());
loop->_lastDeltaFrame = deltaFrame;
}
const uint64_t lifetimeSeconds = app->lifetimeInSeconds();
if (lifetimeSeconds != loop->_lifetimeSeconds) {
metric.gauge("uptime", lifetimeSeconds);
metric->gauge("uptime", lifetimeSeconds);
loop->_lifetimeSeconds = lifetimeSeconds;
}
}
@ -264,7 +264,7 @@ void ServerLoop::update(long dt) {
_network->update();
const int eventSkip = _eventBus->update(200);
if (eventSkip != _lastEventSkip) {
_metricMgr->metric().gauge("events.skip", eventSkip);
_metricMgr->metric()->gauge("events.skip", eventSkip);
_lastEventSkip = eventSkip;
}
}

34
src/modules/backend/metric/MetricMgr.cpp
View File

@ -13,9 +13,9 @@
namespace backend {
MetricMgr::MetricMgr(
const metric::IMetricSenderPtr& metricSender,
const metric::MetricPtr& metric,
const core::EventBusPtr& eventBus) :
_metric("server."), _metricSender(metricSender) {
_metric(metric) {
eventBus->subscribe<EntityAddToMapEvent>(*this);
eventBus->subscribe<EntityRemoveFromMapEvent>(*this);
eventBus->subscribe<EntityAddEvent>(*this);
@ -25,59 +25,49 @@ MetricMgr::MetricMgr(
}
bool MetricMgr::init() {
if (!_metricSender->init()) {
Log::warn("Failed to init metrics");
return false;
}
if (!_metric.init(_metricSender)) {
Log::warn("Failed to init metrics");
// no hard error...
}
return true;
}
void MetricMgr::shutdown() {
_metricSender->shutdown();
_metric.shutdown();
}
void MetricMgr::onEvent(const metric::MetricEvent& event) {
metric::MetricEventType type = event.type();
switch (type) {
case metric::MetricEventType::Count:
_metric.count(event.key().c_str(), event.value(), event.tags());
_metric->count(event.key().c_str(), event.value(), event.tags());
break;
case metric::MetricEventType::Gauge:
_metric.gauge(event.key().c_str(), (uint32_t)event.value(), event.tags());
_metric->gauge(event.key().c_str(), (uint32_t)event.value(), event.tags());
break;
case metric::MetricEventType::Timing:
_metric.timing(event.key().c_str(), (uint32_t)event.value(), event.tags());
_metric->timing(event.key().c_str(), (uint32_t)event.value(), event.tags());
break;
case metric::MetricEventType::Histogram:
_metric.histogram(event.key().c_str(), (uint32_t)event.value(), event.tags());
_metric->histogram(event.key().c_str(), (uint32_t)event.value(), event.tags());
break;
case metric::MetricEventType::Meter:
_metric.meter(event.key().c_str(), event.value(), event.tags());
_metric->meter(event.key().c_str(), event.value(), event.tags());
break;
}
}
void MetricMgr::onEvent(const network::NewConnectionEvent& event) {
Log::info("new connection - waiting for login request from %u", event.peer()->connectID);
_metric.increment("count.user");
_metric->increment("count.user");
}
void MetricMgr::onEvent(const EntityAddEvent& event) {
const EntityPtr& entity = event.entity();
const network::EntityType type = entity->entityType();
const char *typeName = network::EnumNameEntityType(type);
_metric.increment("count.entity", {{"type", typeName}});
_metric->increment("count.entity", {{"type", typeName}});
}
void MetricMgr::onEvent(const EntityDeleteEvent& event) {
const network::EntityType type = event.entityType();
const char *typeName = network::EnumNameEntityType(type);
_metric.decrement("count.entity", {{"type", typeName}});
_metric->decrement("count.entity", {{"type", typeName}});
}
void MetricMgr::onEvent(const EntityAddToMapEvent& event) {
@ -85,7 +75,7 @@ void MetricMgr::onEvent(const EntityAddToMapEvent& event) {
const MapPtr& map = entity->map();
const network::EntityType type = entity->entityType();
const char *typeName = network::EnumNameEntityType(type);
_metric.increment("count.map.entity", {{"map", map->idStr()}, {"type", typeName}});
_metric->increment("count.map.entity", {{"map", map->idStr()}, {"type", typeName}});
}
void MetricMgr::onEvent(const EntityRemoveFromMapEvent& event) {
@ -93,7 +83,7 @@ void MetricMgr::onEvent(const EntityRemoveFromMapEvent& event) {
const MapPtr& map = entity->map();
const network::EntityType type = entity->entityType();
const char *typeName = network::EnumNameEntityType(type);
_metric.decrement("count.map.entity", {{"map", map->idStr()}, {"type", typeName}});
_metric->decrement("count.map.entity", {{"map", map->idStr()}, {"type", typeName}});
}
}

9
src/modules/backend/metric/MetricMgr.h
View File

@ -22,10 +22,9 @@ class MetricMgr :
public core::IEventBusHandler<EntityDeleteEvent>,
public core::IEventBusHandler<EntityAddEvent>{
private:
metric::Metric _metric;
metric::IMetricSenderPtr _metricSender;
metric::MetricPtr _metric;
public:
MetricMgr(const metric::IMetricSenderPtr& metricSender, const core::EventBusPtr& eventBus);
MetricMgr(const metric::MetricPtr& metric, const core::EventBusPtr& eventBus);
void onEvent(const metric::MetricEvent& event);
void onEvent(const network::NewConnectionEvent& event);
@ -34,13 +33,13 @@ public:
void onEvent(const EntityDeleteEvent& event);
void onEvent(const EntityAddEvent& event);
metric::Metric& metric();
metric::MetricPtr& metric();
bool init();
void shutdown();
};
inline metric::Metric& MetricMgr::metric() {
inline metric::MetricPtr& MetricMgr::metric() {
return _metric;
}

73
src/modules/core/App.cpp
View File

@ -9,6 +9,7 @@
#include "command/CommandHandler.h"
#include "io/Filesystem.h"
#include "Common.h"
#include "metric/UDPMetricSender.h"
#include "Log.h"
#include "Tokenizer.h"
#include "Concurrency.h"
@ -22,10 +23,12 @@
namespace core {
App* App::_staticInstance;
thread_local std::stack<App::TraceData> App::_traceData;
App::App(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, size_t threadPoolSize) :
_filesystem(filesystem), _eventBus(eventBus), _threadPool(threadPoolSize, "Core"),
_timeProvider(timeProvider), _metric(metric) {
App::App(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport, size_t threadPoolSize) :
_trace(traceport), _filesystem(filesystem), _eventBus(eventBus), _threadPool(threadPoolSize, "Core"),
_timeProvider(timeProvider) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
_now = systemMillis();
_timeProvider->update(_now);
@ -33,6 +36,9 @@ App::App(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus,
}
App::~App() {
core_trace_set(nullptr);
_metricSender->shutdown();
_metric->shutdown();
Log::shutdown();
}
@ -59,6 +65,35 @@ void App::remBlocker(AppState blockedState) {
_blockers.erase(blockedState);
}
void App::traceBeginFrame(const char *threadName) {
}
void App::traceBegin(const char *threadName, const char* name) {
_traceData.emplace(TraceData{threadName, name, core::TimeProvider::systemNanos()});
}
void App::traceEnd(const char *threadName) {
if (_blockMetricsUntilNextFrame) {
return;
}
core_assert(!_traceData.empty());
TraceData traceData = _traceData.top();
_traceData.pop();
const double dt = core::TimeProvider::systemNanos() - traceData.nanos;
const double dtMillis = dt * 1000.0;
_metric->gauge(traceData.name, uint64_t(dtMillis * 1000.0), {{"thread", traceData.threadName}});
}
void App::traceEndFrame(const char *threadName) {
if (!_blockMetricsUntilNextFrame) {
return;
}
while (!_traceData.empty()) {
_traceData.pop();
}
_blockMetricsUntilNextFrame = false;
}
void App::onFrame() {
core_trace_begin_frame();
if (_nextState != AppState::InvalidAppState && _nextState != _curState) {
@ -151,6 +186,10 @@ AppState App::onConstruct() {
logVar->setVal(logLevelVal);
}
core::Var::get(cfg::CoreSysLog, _syslog ? "true" : "false");
core::Var::get(cfg::MetricFlavor, "telegraf");
core::Var::get(cfg::MetricHost, "127.0.0.1");
core::Var::get(cfg::MetricPort, "8125");
Log::init();
core::Command::registerCommand("set", [] (const core::CmdArgs& args) {
@ -162,6 +201,16 @@ AppState App::onConstruct() {
core::Command::registerCommand("quit", [&] (const core::CmdArgs& args) {requestQuit();}).setHelp("Quit the application");
core::Command::registerCommand("trace", [&] (const core::CmdArgs& args) {
_blockMetricsUntilNextFrame = true;
if (core_trace_set(this) == this) {
core_trace_set(nullptr);
Log::info("Deactivated statsd based tracing metrics");
} else {
Log::info("Activated statsd based tracing metrics");
}
}).setHelp("Toggle application tracing via statsd");
AppCommand::init();
for (int i = 0; i < _argc; ++i) {
@ -185,6 +234,17 @@ AppState App::onConstruct() {
}
core::executeCommands(command + " " + args);
}
_metricSender = std::make_shared<metric::UDPMetricSender>();
if (!_metricSender->init()) {
Log::warn("Failed to init metric sender");
return AppState::Destroy;;
}
if (!_metric->init(_appname.c_str(), _metricSender)) {
Log::warn("Failed to init metrics");
// no hard error...
}
Log::init();
Log::debug("%s: " PROJECT_VERSION, _appname.c_str());
@ -490,6 +550,13 @@ AppState App::onCleanup() {
core_trace_shutdown();
if (_metricSender) {
_metricSender->shutdown();
}
if (_metric) {
_metric->shutdown();
}
return AppState::Destroy;
}

24
src/modules/core/App.h
View File

@ -9,10 +9,13 @@
#include "Common.h"
#include "Assert.h"
#include "Var.h"
#include "metric/Metric.h"
#include "core/Trace.h"
#include "EventBus.h"
#include "TimeProvider.h"
#include "core/ThreadPool.h"
#include <stack>
#include <atomic>
#define ORGANISATION "engine"
@ -38,8 +41,9 @@ enum class AppState : uint8_t {
/**
* @brief The app class controls the main loop of every application.
*/
class App {
class App : public core::TraceCallback {
protected:
// Deprecated
class ProfilerCPU {
private:
double _min = 0.0;
@ -62,6 +66,7 @@ protected:
};
template<class Profiler>
// Deprecated
struct ScopedProfiler {
Profiler& _p;
inline ScopedProfiler(Profiler& p) : _p(p) {
@ -98,6 +103,16 @@ protected:
core::TimeProviderPtr _timeProvider;
core::VarPtr _logLevelVar;
core::VarPtr _syslogVar;
metric::IMetricSenderPtr _metricSender;
metric::MetricPtr _metric;
// if you modify the tracing during the frame, we throw away the current frame information
std::atomic_bool _blockMetricsUntilNextFrame { false };
struct TraceData {
const char *threadName;
const char *name;
double nanos;
};
static thread_local std::stack<TraceData> _traceData;
/**
* @brief There is no fps limit per default, but you set one on a per-app basis
@ -107,10 +122,15 @@ protected:
_framesPerSecondsCap = framesPerSecondsCap;
}
virtual void traceBeginFrame(const char *threadName) override;
virtual void traceBegin(const char *threadName, const char* name) override;
virtual void traceEnd(const char *threadName) override;
virtual void traceEndFrame(const char *threadName) override;
void usage() const;
public:
App(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport, size_t threadPoolSize = 1);
App(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, size_t threadPoolSize = 1);
virtual ~App();
void init(const std::string& organisation, const std::string& appname);

2
src/modules/core/CMakeLists.txt
View File

@ -40,7 +40,7 @@ set(SRCS
)
set(LIB core)
add_library(${LIB} ${SRCS})
engine_target_link_libraries(TARGET ${LIB} DEPENDENCIES collection io restclient-cpp zlib ${CMAKE_DL_LIBS})
engine_target_link_libraries(TARGET ${LIB} DEPENDENCIES collection io metric restclient-cpp zlib ${CMAKE_DL_LIBS})
set_target_properties(${LIB} PROPERTIES FOLDER ${LIB})
set(TEST_SRCS

4
src/modules/core/ConsoleApp.cpp
View File

@ -6,8 +6,8 @@
namespace core {
ConsoleApp::ConsoleApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport, size_t threadPoolSize) :
Super(filesystem, eventBus, timeProvider, traceport, threadPoolSize) {
ConsoleApp::ConsoleApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, size_t threadPoolSize) :
Super(metric, filesystem, eventBus, timeProvider, threadPoolSize) {
}
ConsoleApp::~ConsoleApp() {

2
src/modules/core/ConsoleApp.h
View File

@ -12,7 +12,7 @@ class ConsoleApp : public App {
private:
using Super = core::App;
public:
ConsoleApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport, size_t threadPoolSize = 1);
ConsoleApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, size_t threadPoolSize = 1);
virtual ~ConsoleApp();
virtual AppState onConstruct() override;

17
src/modules/core/Trace.cpp
View File

@ -17,12 +17,13 @@ namespace core {
namespace {
static TraceCallback* _callback = nullptr;
static thread_local const char* _threadName = "Unknown";
}
Trace::Trace(uint16_t port) {
Trace::Trace() {
#if USE_EMTRACE
emscripten_trace_configure(core::string::format("http://localhost:%i/", (int)port).c_str(), "Engine");
emscripten_trace_configure("http://localhost:17000/", "Engine");
#endif
traceThread("MainThread");
}
@ -77,11 +78,10 @@ void traceBeginFrame() {
emscripten_trace_record_frame_start();
#else
if (_callback != nullptr) {
_callback->traceBeginFrame();
_callback->traceBeginFrame(_threadName);
} else {
traceBegin("Frame");
}
#endif
}
@ -90,7 +90,7 @@ void traceEndFrame() {
emscripten_trace_record_frame_end();
#else
if (_callback != nullptr) {
_callback->traceEndFrame();
_callback->traceEndFrame(_threadName);
} else {
traceEnd();
}
@ -102,7 +102,7 @@ void traceBegin(const char* name) {
emscripten_trace_enter_context(name);
#else
if (_callback != nullptr) {
_callback->traceBegin(name);
_callback->traceBegin(_threadName, name);
}
#endif
}
@ -112,7 +112,7 @@ void traceEnd() {
emscripten_trace_exit_context();
#else
if (_callback != nullptr) {
_callback->traceEnd();
_callback->traceEnd(_threadName);
}
#endif
}
@ -132,7 +132,8 @@ void traceMessage(const char* message) {
Log::trace("%s", message);
}
void traceThread(const char* name) {
void traceThread(const char* name) {
_threadName = name;
traceMessage(name);
}

10
src/modules/core/Trace.h
View File

@ -11,7 +11,7 @@ namespace core {
// a singleton - available via core::App
class Trace {
public:
Trace(uint16_t port = 17815);
Trace();
~Trace();
};
@ -30,10 +30,10 @@ public:
class TraceCallback {
public:
virtual ~TraceCallback() {}
virtual void traceBeginFrame() {}
virtual void traceBegin(const char *name) = 0;
virtual void traceEnd() = 0;
virtual void traceEndFrame() {}
virtual void traceBeginFrame(const char *threadName) {}
virtual void traceBegin(const char *threadName, const char *name) = 0;
virtual void traceEnd(const char *threadName) = 0;
virtual void traceEndFrame(const char *threadName) {}
};
extern TraceCallback* traceSet(TraceCallback* callback);

7
src/modules/core/benchmark/AbstractBenchmark.cpp
View File

@ -13,7 +13,8 @@ void AbstractBenchmark::SetUp(benchmark::State& st) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
_benchmarkApp = new BenchmarkApp(filesystem, eventBus, timeProvider, this);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
_benchmarkApp = new BenchmarkApp(metric, filesystem, eventBus, timeProvider, this);
}
void AbstractBenchmark::TearDown(benchmark::State& st) {
@ -23,8 +24,8 @@ void AbstractBenchmark::TearDown(benchmark::State& st) {
_benchmarkApp = nullptr;
}
AbstractBenchmark::BenchmarkApp::BenchmarkApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractBenchmark* benchmark) :
Super(filesystem, eventBus, timeProvider, 10000), _benchmark(benchmark) {
AbstractBenchmark::BenchmarkApp::BenchmarkApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractBenchmark* benchmark) :
Super(metric, filesystem, eventBus, timeProvider), _benchmark(benchmark) {
init(ORGANISATION, "benchmark");
while (_curState < AppState::Running) {
core_trace_scoped(AppMainLoop);

2
src/modules/core/benchmark/AbstractBenchmark.h
View File

@ -14,7 +14,7 @@ private:
using Super = core::ConsoleApp;
AbstractBenchmark* _benchmark = nullptr;
public:
BenchmarkApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractBenchmark* benchmark);
BenchmarkApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractBenchmark* benchmark);
~BenchmarkApp();
virtual core::AppState onInit() override;

8
src/modules/core/tests/AbstractTest.cpp
View File

@ -6,6 +6,7 @@
#include "core/Log.h"
#include "core/Var.h"
#include "core/command/Command.h"
#include "metric/Metric.h"
extern char **_argv;
extern int _argc;
@ -16,7 +17,8 @@ void AbstractTest::SetUp() {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
_testApp = new TestApp(filesystem, eventBus, timeProvider, this);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
_testApp = new TestApp(metric, filesystem, eventBus, timeProvider, this);
const bool isRunning = _testApp->_curState == AppState::Running;
ASSERT_TRUE(isRunning) << "Failed to setup the test app properly";
}
@ -28,8 +30,8 @@ void AbstractTest::TearDown() {
_testApp = nullptr;
}
AbstractTest::TestApp::TestApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractTest* test) :
Super(filesystem, eventBus, timeProvider, 10000), _test(test) {
AbstractTest::TestApp::TestApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractTest* test) :
Super(metric, filesystem, eventBus, timeProvider), _test(test) {
init(ORGANISATION, "test");
_argc = ::_argc;
_argv = ::_argv;

2
src/modules/core/tests/AbstractTest.h
View File

@ -84,7 +84,7 @@ private:
protected:
AbstractTest* _test = nullptr;
public:
TestApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractTest* test);
TestApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, AbstractTest* test);
~TestApp();
AppState onInit() override;

12
src/modules/metric/Metric.cpp
View File

@ -12,15 +12,12 @@
namespace metric {
Metric::Metric(const char* prefix) :
_prefix(prefix) {
}
Metric::~Metric() {
shutdown();
}
bool Metric::init(const IMetricSenderPtr& messageSender) {
bool Metric::init(const char *prefix, const IMetricSenderPtr& messageSender) {
_prefix = prefix;
const std::string& flavor = core::Var::getSafe(cfg::MetricFlavor)->strVal();
if (flavor == "telegraf") {
_flavor = Flavor::Telegraf;
@ -39,6 +36,7 @@ bool Metric::init(const IMetricSenderPtr& messageSender) {
}
void Metric::shutdown() {
_messageSender = IMetricSenderPtr();
}
bool Metric::createTags(char* buffer, size_t len, const TagMap& tags, const char* sep, const char* preamble, const char *split) const {
@ -77,6 +75,9 @@ bool Metric::createTags(char* buffer, size_t len, const TagMap& tags, const char
}
bool Metric::assemble(const char* key, int value, const char* type, const TagMap& tags) const {
if (!_messageSender) {
return false;
}
constexpr int metricSize = 256;
char buffer[metricSize];
constexpr int tagsSize = 256;
@ -103,7 +104,6 @@ bool Metric::assemble(const char* key, int value, const char* type, const TagMap
if (written >= metricSize) {
return false;
}
core_assert_always(_messageSender);
return _messageSender->send(buffer);
}

8
src/modules/metric/Metric.h
View File

@ -7,6 +7,7 @@
#include "IMetricSender.h"
#include "core/NonCopyable.h"
#include <map>
#include <memory>
#include <string>
#include <stdint.h>
@ -22,7 +23,7 @@ using TagMap = std::map<std::string, std::string>;
class Metric : public core::NonCopyable {
private:
const std::string _prefix;
std::string _prefix;
Flavor _flavor = Flavor::Telegraf;
IMetricSenderPtr _messageSender;
@ -38,14 +39,13 @@ private:
bool createTags(char *buffer, size_t len, const TagMap& tags, const char* sep, const char* preamble, const char *split = ",") const;
bool assemble(const char* key, int value, const char* type, const TagMap& tags = {}) const;
public:
Metric(const char* prefix);
~Metric();
/**
* @param[in] messageSender @c IMessageSender - must already be initialized
* @note Reads the @c metric_flavor cvar to configure the flavor.
*/
bool init(const IMetricSenderPtr& messageSender);
bool init(const char *prefix, const IMetricSenderPtr& messageSender);
void shutdown();
/**
@ -141,4 +141,6 @@ inline bool Metric::meter(const char* key, int value, const TagMap& tags) const
return assemble(key, value, "m", tags);
}
using MetricPtr = std::shared_ptr<Metric>;
}

2
src/modules/metric/UDPMetricSender.cpp
View File

@ -37,7 +37,7 @@ UDPMetricSender::UDPMetricSender() :
bool UDPMetricSender::init() {
_port = core::Var::getSafe(cfg::MetricPort)->intVal();
_host = core::Var::getSafe(cfg::MetricHost)->strVal();
Log::info("metric udp sender %s:%i", _host.c_str(), (int)_port);
Log::debug("metric udp sender %s:%i", _host.c_str(), (int)_port);
#ifdef WIN32
WSADATA wsaData;
const int wsaResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

12
src/modules/metric/tests/MetricTest.cpp
View File

@ -49,8 +49,8 @@ protected:
} else if (flavor == Flavor::Datadog) {
core::Var::get("metric_flavor", "")->setVal("datadog");
}
Metric m(PREFIX);
m.init(sender);
Metric m;
m.init(PREFIX, sender);
m.count(id, value, tags);
return sender->metricLine();
}
@ -63,8 +63,8 @@ protected:
} else if (flavor == Flavor::Datadog) {
core::Var::get("metric_flavor", "")->setVal("datadog");
}
Metric m(PREFIX);
m.init(sender);
Metric m;
m.init(PREFIX, sender);
m.gauge(id, value, tags);
return sender->metricLine();
}
@ -77,8 +77,8 @@ protected:
} else if (flavor == Flavor::Datadog) {
core::Var::get("metric_flavor", "")->setVal("datadog");
}
Metric m(PREFIX);
m.init(sender);
Metric m;
m.init(PREFIX, sender);
m.timing(id, value, tags);
return sender->metricLine();
}

1
src/modules/testcore/CMakeLists.txt
View File

@ -1,6 +1,7 @@
set(SRCS
TestApp.cpp TestApp.h
TestMeshApp.cpp TestMeshApp.h
TestAppMain.h
)
set(LIB testcore)
add_library(${LIB} ${SRCS})

4
src/modules/testcore/TestApp.cpp
View File

@ -5,8 +5,8 @@
#include "frontend/Movement.h"
#include "video/ScopedPolygonMode.h"
TestApp::TestApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider, 21000) {
TestApp::TestApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "test");
}

3
src/modules/testcore/TestApp.h
View File

@ -4,6 +4,7 @@
#pragma once
#include "TestAppMain.h"
#include "ui/imgui/IMGUIApp.h"
#include "ui/imgui/IMGUI.h"
#include "video/Mesh.h"
@ -45,7 +46,7 @@ protected:
}
public:
TestApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual ~TestApp();
video::Camera& camera();

15
src/modules/testcore/TestAppMain.h Normal file
View File

@ -0,0 +1,15 @@
/**
* @file
*/
#pragma once
#define TEST_APP(testClassName) \
int main(int argc, char *argv[]) { \
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>(); \
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>(); \
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>(); \
const metric::MetricPtr& metric = std::make_shared<metric::Metric>(); \
testClassName app(metric, filesystem, eventBus, timeProvider); \
return app.startMainLoop(argc, argv); \
}

4
src/modules/testcore/TestMeshApp.cpp
View File

@ -8,8 +8,8 @@
#define MaxDepthBufferUniformName "u_cascades"
TestMeshApp::TestMeshApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider), _colorShader(shader::ColorShader::getInstance()) {
TestMeshApp::TestMeshApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider), _colorShader(shader::ColorShader::getInstance()) {
setCameraMotion(true);
setRenderPlane(false);
_fogColor = core::Color::LightBlue;

2
src/modules/testcore/TestMeshApp.h
View File

@ -47,7 +47,7 @@ protected:
virtual void doRender() override;
virtual void onRenderUI() override;
public:
TestMeshApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestMeshApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual core::AppState onConstruct() override;
virtual core::AppState onInit() override;

14
src/modules/ui/imgui/IMGUIApp.cpp
View File

@ -20,16 +20,14 @@ namespace imgui {
thread_local int IMGUIApp::_currentFrameCounter = 0;
IMGUIApp::IMGUIApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport) :
Super(filesystem, eventBus, timeProvider, traceport), _camera(video::CameraType::FirstPerson, video::CameraMode::Orthogonal) {
core_trace_set(this);
IMGUIApp::IMGUIApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider), _camera(video::CameraType::FirstPerson, video::CameraMode::Orthogonal) {
}
IMGUIApp::~IMGUIApp() {
core_trace_set(nullptr);
}
void IMGUIApp::traceBeginFrame() {
void IMGUIApp::traceBeginFrame(const char *threadName) {
std::lock_guard<std::mutex> lock(_traceMutex);
const std::thread::id id = std::this_thread::get_id();
auto i = _traceMeasures.find(id);
@ -38,7 +36,7 @@ void IMGUIApp::traceBeginFrame() {
}
}
void IMGUIApp::traceBegin(const char* name) {
void IMGUIApp::traceBegin(const char *threadName, const char* name) {
std::lock_guard<std::mutex> lock(_traceMutex);
const std::thread::id id = std::this_thread::get_id();
auto measureIter = _traceMeasures.find(id);
@ -56,7 +54,7 @@ void IMGUIApp::traceBegin(const char* name) {
}
}
void IMGUIApp::traceEnd() {
void IMGUIApp::traceEnd(const char *threadName) {
std::lock_guard<std::mutex> lock(_traceMutex);
const std::thread::id id = std::this_thread::get_id();
auto measureIter = _traceMeasures.find(id);
@ -68,7 +66,7 @@ void IMGUIApp::traceEnd() {
value.begin = false;
}
void IMGUIApp::traceEndFrame() {
void IMGUIApp::traceEndFrame(const char *threadName) {
++_currentFrameCounter;
}

13
src/modules/ui/imgui/IMGUIApp.h
View File

@ -9,7 +9,6 @@
#include "video/VertexBuffer.h"
#include "ImguiShaders.h"
#include "Console.h"
#include "core/Trace.h"
#include <atomic>
#include <map>
#include <thread>
@ -23,7 +22,7 @@ namespace imgui {
/**
* @ingroup UI
*/
class IMGUIApp: public video::WindowedApp, public core::TraceCallback {
class IMGUIApp: public video::WindowedApp {
private:
using Super = video::WindowedApp;
protected:
@ -54,10 +53,10 @@ protected:
using FramesMillis = std::array<float, _maxMeasureSize>;
FramesMillis _frameMillis {0.0f};
virtual void traceBeginFrame() override;
virtual void traceBegin(const char* name) override;
virtual void traceEnd() override;
virtual void traceEndFrame() override;
virtual void traceBeginFrame(const char *threadName) override;
virtual void traceBegin(const char *threadName, const char* name) override;
virtual void traceEnd(const char *threadName) override;
virtual void traceEndFrame(const char *threadName) override;
void renderTracing();
virtual bool onKeyRelease(int32_t key) override;
@ -67,7 +66,7 @@ protected:
virtual void onMouseButtonRelease(int32_t x, int32_t y, uint8_t button) override;
virtual void onMouseButtonPress(int32_t x, int32_t y, uint8_t button, uint8_t clicks) override;
public:
IMGUIApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport = 17815);
IMGUIApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual ~IMGUIApp();
virtual void beforeUI() {

8
src/modules/ui/nuklear/LUAUIApp.cpp
View File

@ -13,12 +13,12 @@
namespace ui {
namespace nuklear {
LUAUIApp::LUAUIApp(const io::FilesystemPtr& filesystem,
LUAUIApp::LUAUIApp(const metric::MetricPtr& metric,
const io::FilesystemPtr& filesystem,
const core::EventBusPtr& eventBus,
const core::TimeProviderPtr& timeProvider,
const video::TexturePoolPtr& texturePool,
uint16_t traceport) :
Super(filesystem, eventBus, timeProvider, traceport), _lua(false), _texturePool(texturePool) {
const video::TexturePoolPtr& texturePool) :
Super(metric, filesystem, eventBus, timeProvider), _lua(false), _texturePool(texturePool) {
}
LUAUIApp::~LUAUIApp() {

2
src/modules/ui/nuklear/LUAUIApp.h
View File

@ -24,7 +24,7 @@ protected:
video::TexturePoolPtr _texturePool;
bool _skipUntilReload = true;
public:
LUAUIApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::TexturePoolPtr& texturePool, uint16_t traceport = 17815);
LUAUIApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::TexturePoolPtr& texturePool);
virtual ~LUAUIApp();
core::AppState onInit() override;

4
src/modules/ui/nuklear/NuklearApp.cpp
View File

@ -17,8 +17,8 @@ namespace nuklear {
static const int MAX_VERTEX_MEMORY = 32768 * sizeof(NuklearApp::Vertex);
static const int MAX_ELEMENT_MEMORY = 65536;
NuklearApp::NuklearApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport) :
Super(filesystem, eventBus, timeProvider, traceport), _camera(video::CameraType::FirstPerson, video::CameraMode::Orthogonal) {
NuklearApp::NuklearApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider), _camera(video::CameraType::FirstPerson, video::CameraMode::Orthogonal) {
}
NuklearApp::~NuklearApp() {

2
src/modules/ui/nuklear/NuklearApp.h
View File

@ -58,7 +58,7 @@ protected:
virtual void onMouseButtonPress(int32_t x, int32_t y, uint8_t button, uint8_t clicks) override;
virtual void onMouseButtonRelease(int32_t x, int32_t y, uint8_t button) override;
public:
NuklearApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport = 17815);
NuklearApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual ~NuklearApp();
virtual bool onRenderUI() = 0;

4
src/modules/ui/turbobadger/UIApp.cpp
View File

@ -140,8 +140,8 @@ static inline int mapKey(int32_t key) {
tb::UIRendererGL _renderer;
UIApp::UIApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport) :
Super(filesystem, eventBus, timeProvider, traceport) {
UIApp::UIApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
}
UIApp::~UIApp() {

2
src/modules/ui/turbobadger/UIApp.h
View File

@ -41,7 +41,7 @@ protected:
tb::MODIFIER_KEYS getModifierKeys() const;
public:
UIApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport = 17815);
UIApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual ~UIApp();
virtual void beforeUI() {

4
src/modules/video/WindowedApp.cpp
View File

@ -32,8 +32,8 @@ inline void checkSDLError(const char *file, unsigned int line, const char *funct
#define sdlCheckError() checkSDLError(__FILE__, __LINE__, SDL_FUNCTION)
}
WindowedApp::WindowedApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport) :
Super(filesystem, eventBus, timeProvider, traceport), _dimension(-1), _mousePos(-1), _mouseRelativePos(-1) {
WindowedApp::WindowedApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider), _dimension(-1), _mousePos(-1), _mouseRelativePos(-1) {
}
WindowedApp::~WindowedApp() {

2
src/modules/video/WindowedApp.h
View File

@ -42,7 +42,7 @@ protected:
glm::ivec2 _mousePos;
glm::ivec2 _mouseRelativePos;
WindowedApp(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, uint16_t traceport = 17815);
WindowedApp(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
bool loadKeyBindings(const std::string& filename = "keybindings.cfg");

14
src/server/Server.cpp
View File

@ -23,13 +23,12 @@
#include "persistence/DBHandler.h"
#include "persistence/PersistenceMgr.h"
#include "stock/StockDataProvider.h"
#include "metric/UDPMetricSender.h"
#include <stdlib.h>
Server::Server(const backend::ServerLoopPtr& serverLoop,
Server::Server(const metric::MetricPtr& metric, const backend::ServerLoopPtr& serverLoop,
const core::TimeProviderPtr& timeProvider, const io::FilesystemPtr& filesystem,
const core::EventBusPtr& eventBus) :
Super(filesystem, eventBus, timeProvider, 15678),
Super(metric, filesystem, eventBus, timeProvider),
_serverLoop(serverLoop) {
_syslog = true;
_coredump = true;
@ -41,9 +40,6 @@ Server::Server(const backend::ServerLoopPtr& serverLoop,
core::AppState Server::onConstruct() {
const core::AppState state = Super::onConstruct();
core::Var::get(cfg::MetricFlavor, "telegraf");
core::Var::get(cfg::MetricHost, "127.0.0.1");
core::Var::get(cfg::MetricPort, "8125");
core::Var::get(cfg::DatabaseName, "engine");
core::Var::get(cfg::DatabaseHost, "localhost");
core::Var::get(cfg::DatabaseUser, "engine");
@ -112,14 +108,14 @@ int main(int argc, char *argv[]) {
const eventmgr::EventProviderPtr& eventProvider = std::make_shared<eventmgr::EventProvider>(dbHandler);
const eventmgr::EventMgrPtr& eventMgr = std::make_shared<eventmgr::EventMgr>(eventProvider, timeProvider);
const metric::IMetricSenderPtr& metricSender = std::make_shared<metric::UDPMetricSender>();
const backend::WorldPtr& world = std::make_shared<backend::World>(mapProvider, registry, eventBus, filesystem);
const backend::MetricMgrPtr& metricMgr = std::make_shared<backend::MetricMgr>(metricSender, eventBus);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
const backend::MetricMgrPtr& metricMgr = std::make_shared<backend::MetricMgr>(metric, eventBus);
const persistence::PersistenceMgrPtr& persistenceMgr = std::make_shared<persistence::PersistenceMgr>(dbHandler);
const backend::ServerLoopPtr& serverLoop = std::make_shared<backend::ServerLoop>(timeProvider, mapProvider,
messageSender, world, dbHandler, network, filesystem, entityStorage, eventBus, containerProvider,
cooldownProvider, eventMgr, stockDataProvider, metricMgr, persistenceMgr);
Server app(serverLoop, timeProvider, filesystem, eventBus);
Server app(metric, serverLoop, timeProvider, filesystem, eventBus);
return app.startMainLoop(argc, argv);
}

2
src/server/Server.h
View File

@ -13,7 +13,7 @@ private:
using Super = core::ConsoleApp;
backend::ServerLoopPtr _serverLoop;
public:
Server(const backend::ServerLoopPtr& serverLoop,
Server(const metric::MetricPtr& metric, const backend::ServerLoopPtr& serverLoop,
const core::TimeProviderPtr& timeProvider, const io::FilesystemPtr& filesystem,
const core::EventBusPtr& eventBus);

12
src/tests/testcamera/TestCamera.cpp
View File

@ -2,8 +2,8 @@
#include "ui/imgui/IMGUI.h"
#include "io/Filesystem.h"
TestCamera::TestCamera(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestCamera::TestCamera(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testcamera");
setCameraMotion(true);
//setRenderPlane(true);
@ -195,10 +195,4 @@ bool TestCamera::onKeyPress(int32_t key, int16_t modifier) {
return retVal;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestCamera app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestCamera)

2
src/tests/testcamera/TestCamera.h
View File

@ -28,7 +28,7 @@ private:
void doRender() override;
void resetCameraPosition();
public:
TestCamera(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestCamera(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
core::AppState onRunning() override;

12
src/tests/testdepthbuffer/TestDepthBuffer.cpp
View File

@ -2,8 +2,8 @@
#include "video/ScopedViewPort.h"
#include "io/Filesystem.h"
TestDepthBuffer::TestDepthBuffer(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestDepthBuffer::TestDepthBuffer(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testdepthbuffer");
}
@ -54,10 +54,4 @@ core::AppState TestDepthBuffer::onCleanup() {
return Super::onCleanup();
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestDepthBuffer app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestDepthBuffer)

2
src/tests/testdepthbuffer/TestDepthBuffer.h
View File

@ -15,7 +15,7 @@ private:
void doRender() override;
public:
TestDepthBuffer(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestDepthBuffer(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
core::AppState onCleanup() override;

13
src/tests/testimgui/TestIMGUI.cpp
View File

@ -2,11 +2,12 @@
* @file
*/
#include "TestIMGUI.h"
#include "testcore/TestAppMain.h"
#include "io/Filesystem.h"
#include "core/Color.h"
TestIMGUI::TestIMGUI(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestIMGUI::TestIMGUI(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testimgui");
}
@ -51,10 +52,4 @@ core::AppState TestIMGUI::onInit() {
return state;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestIMGUI app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestIMGUI)

2
src/tests/testimgui/TestIMGUI.h
View File

@ -17,7 +17,7 @@ private:
bool _showMetricsWindow = false;
public:
TestIMGUI(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestIMGUI(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
void onRenderUI() override;

10
src/tests/testluaui/TestLUAUI.cpp
View File

@ -1,11 +1,14 @@
/**
* @file
*/
#include "TestLUAUI.h"
#include "io/Filesystem.h"
#include "video/TexturePool.h"
#include "core/TimeProvider.h"
#include "core/EventBus.h"
TestLUAUI::TestLUAUI(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::TexturePoolPtr& texturePool) :
Super(filesystem, eventBus, timeProvider, texturePool) {
TestLUAUI::TestLUAUI(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::TexturePoolPtr& texturePool) :
Super(metric, filesystem, eventBus, timeProvider, texturePool) {
init(ORGANISATION, "testluaui");
}
@ -14,6 +17,7 @@ int main(int argc, char *argv[]) {
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const video::TexturePoolPtr& texturePool = std::make_shared<video::TexturePool>();
TestLUAUI app(filesystem, eventBus, timeProvider, texturePool);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
TestLUAUI app(metric, filesystem, eventBus, timeProvider, texturePool);
return app.startMainLoop(argc, argv);
}

2
src/tests/testluaui/TestLUAUI.h
View File

@ -10,5 +10,5 @@ class TestLUAUI: public ui::nuklear::LUAUIApp {
private:
using Super = ui::nuklear::LUAUIApp;
public:
TestLUAUI(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::TexturePoolPtr& texturePool);
TestLUAUI(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::TexturePoolPtr& texturePool);
};

6
src/tests/testmesh/TestMesh.cpp
View File

@ -1,3 +1,6 @@
/**
* @file
*/
#include "testcore/TestMeshApp.h"
#include "io/Filesystem.h"
@ -5,6 +8,7 @@ int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestMeshApp app(filesystem, eventBus, timeProvider);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
TestMeshApp app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

17
src/tests/testnuklear/TestNuklear.cpp
View File

@ -1,10 +1,15 @@
/**
* @file
*/
#include "TestNuklear.h"
#include "testcore/TestAppMain.h"
#include "io/Filesystem.h"
#include "ui/nuklear/Nuklear.h"
#include "overview.c"
TestNuklear::TestNuklear(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestNuklear::TestNuklear(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testnuklear");
}
@ -13,10 +18,4 @@ bool TestNuklear::onRenderUI() {
return true;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
TestNuklear app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestNuklear)

2
src/tests/testnuklear/TestNuklear.h
View File

@ -10,7 +10,7 @@ class TestNuklear: public ui::nuklear::NuklearApp {
private:
using Super = ui::nuklear::NuklearApp;
public:
TestNuklear(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestNuklear(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
bool onRenderUI() override;
};

15
src/tests/testoctree/TestOctree.cpp
View File

@ -1,3 +1,6 @@
/**
* @file
*/
#include "TestOctree.h"
#include "io/Filesystem.h"
#include "ui/imgui/IMGUI.h"
@ -5,8 +8,8 @@
#include "video/ScopedLineWidth.h"
#include <array>
TestOctree::TestOctree(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestOctree::TestOctree(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testoctree");
setCameraMotion(true);
//setRenderPlane(true);
@ -241,10 +244,4 @@ core::AppState TestOctree::onCleanup() {
return state;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestOctree app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestOctree)

2
src/tests/testoctree/TestOctree.h
View File

@ -59,7 +59,7 @@ private:
void insert();
void doRender() override;
public:
TestOctree(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestOctree(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual bool onKeyPress(int32_t key, int16_t modifier) override;

15
src/tests/testoctreevisit/TestOctreeVisit.cpp
View File

@ -1,3 +1,6 @@
/**
* @file
*/
#include "TestOctreeVisit.h"
#include "io/Filesystem.h"
@ -7,8 +10,8 @@
#include "video/ScopedLineWidth.h"
#include <array>
TestOctreeVisit::TestOctreeVisit(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestOctreeVisit::TestOctreeVisit(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testoctreevisit");
setCameraMotion(true);
//setRenderPlane(true);
@ -116,10 +119,4 @@ core::AppState TestOctreeVisit::onCleanup() {
return state;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestOctreeVisit app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestOctreeVisit)

2
src/tests/testoctreevisit/TestOctreeVisit.h
View File

@ -47,7 +47,7 @@ private:
void doRender() override;
void onRenderUI() override;
public:
TestOctreeVisit(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestOctreeVisit(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual core::AppState onInit() override;
virtual core::AppState onRunning() override;

15
src/tests/testplane/TestPlane.cpp
View File

@ -1,8 +1,11 @@
/**
* @file
*/
#include "TestPlane.h"
#include "io/Filesystem.h"
TestPlane::TestPlane(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestPlane::TestPlane(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
setCameraMotion(true);
setRenderAxis(true);
}
@ -33,10 +36,4 @@ core::AppState TestPlane::onCleanup() {
return state;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestPlane app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestPlane)

2
src/tests/testplane/TestPlane.h
View File

@ -22,7 +22,7 @@ private:
void doRender() override;
public:
TestPlane(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestPlane(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
core::AppState onCleanup() override;

15
src/tests/testshapebuilder/TestShapeBuilder.cpp
View File

@ -1,3 +1,6 @@
/**
* @file
*/
#include "TestShapeBuilder.h"
#include "io/Filesystem.h"
#include "core/Color.h"
@ -6,8 +9,8 @@
#include "core/GLM.h"
#include "ui/imgui/IMGUI.h"
TestShapeBuilder::TestShapeBuilder(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider), _color(core::Color::DarkGreen) {
TestShapeBuilder::TestShapeBuilder(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider), _color(core::Color::DarkGreen) {
init(ORGANISATION, "testshapebuilder");
setCameraMotion(true);
setRenderPlane(true);
@ -187,10 +190,4 @@ core::AppState TestShapeBuilder::onCleanup() {
return state;
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestShapeBuilder app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestShapeBuilder)

2
src/tests/testshapebuilder/TestShapeBuilder.h
View File

@ -27,7 +27,7 @@ private:
void doRender() override;
void onRenderUI() override;
public:
TestShapeBuilder(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestShapeBuilder(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual core::AppState onInit() override;
virtual core::AppState onCleanup() override;

15
src/tests/testtemplate/TestTemplate.cpp
View File

@ -1,8 +1,11 @@
/**
* @file
*/
#include "TestTemplate.h"
#include "io/Filesystem.h"
TestTemplate::TestTemplate(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestTemplate::TestTemplate(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testtemplate");
}
@ -23,10 +26,4 @@ core::AppState TestTemplate::onCleanup() {
void TestTemplate::doRender() {
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestTemplate app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestTemplate)

2
src/tests/testtemplate/TestTemplate.h
View File

@ -12,7 +12,7 @@ private:
void doRender() override;
public:
TestTemplate(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestTemplate(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
virtual core::AppState onInit() override;
virtual core::AppState onCleanup() override;

16
src/tests/testtexture/TestTexture.cpp
View File

@ -1,11 +1,14 @@
/**
* @file
*/
#include "TestTexture.h"
#include "core/Color.h"
#include "video/Camera.h"
#include "video/ScopedViewPort.h"
#include "io/Filesystem.h"
TestTexture::TestTexture(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestTexture::TestTexture(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testtexture");
}
@ -74,11 +77,4 @@ core::AppState TestTexture::onCleanup() {
return Super::onCleanup();
}
int main(int argc, char *argv[]) {
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
TestTexture app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestTexture)

2
src/tests/testtexture/TestTexture.h
View File

@ -18,7 +18,7 @@ private:
void doRender() override;
public:
TestTexture(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestTexture(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
core::AppState onCleanup() override;

15
src/tests/testvoxelfont/TestVoxelFont.cpp
View File

@ -1,10 +1,13 @@
/**
* @file
*/
#include "TestVoxelFont.h"
#include "voxel/MaterialColor.h"
#include "io/Filesystem.h"
#include "ui/imgui/IMGUI.h"
TestVoxelFont::TestVoxelFont(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
TestVoxelFont::TestVoxelFont(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "testvoxelfont");
setCameraMotion(true);
}
@ -146,10 +149,4 @@ void TestVoxelFont::doRender() {
_rawVolumeRenderer.render(_camera);
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
TestVoxelFont app(filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}
TEST_APP(TestVoxelFont)

2
src/tests/testvoxelfont/TestVoxelFont.h
View File

@ -28,7 +28,7 @@ private:
bool changeFontSize(int delta);
public:
TestVoxelFont(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
TestVoxelFont(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
void onRenderUI() override;

13
src/tools/computeshadertool/ComputeShaderTool.cpp
View File

@ -13,8 +13,8 @@
#include <stack>
#include <string>
ComputeShaderTool::ComputeShaderTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider, 0) {
ComputeShaderTool::ComputeShaderTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "computeshadertool");
}
@ -85,9 +85,10 @@ core::AppState ComputeShaderTool::onRunning() {
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
ComputeShaderTool app(filesystem, eventBus, timeProvider);
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
ComputeShaderTool app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/computeshadertool/ComputeShaderTool.h
View File

@ -37,7 +37,7 @@ protected:
bool parse(const std::string& src);
public:
ComputeShaderTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
ComputeShaderTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
~ComputeShaderTool();
core::AppState onConstruct() override;

13
src/tools/databasetool/DatabaseTool.cpp
View File

@ -12,8 +12,8 @@
#include "Generator.h"
#include "Table.h"
DatabaseTool::DatabaseTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider, 0) {
DatabaseTool::DatabaseTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "databasetool");
}
@ -167,9 +167,10 @@ core::AppState DatabaseTool::onRunning() {
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
DatabaseTool app(filesystem, eventBus, timeProvider);
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
DatabaseTool app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/databasetool/DatabaseTool.h
View File

@ -29,7 +29,7 @@ protected:
bool parse(const std::string& src);
bool generateSrc() const;
public:
DatabaseTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
DatabaseTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onConstruct() override;
core::AppState onRunning() override;

7
src/tools/noisetool/NoiseTool.cpp
View File

@ -7,8 +7,8 @@
#include "ui/NoiseToolWindow.h"
#include "ui/noisedata/NoiseDataItemWidget.h"
NoiseTool::NoiseTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
NoiseTool::NoiseTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "noisetool");
}
@ -59,6 +59,7 @@ int main(int argc, char *argv[]) {
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
NoiseTool app(filesystem, eventBus, timeProvider);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
NoiseTool app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/noisetool/NoiseTool.h
View File

@ -25,7 +25,7 @@ private:
NoiseToolWindow* _window = nullptr;
NoiseItemSource* _noiseItemSource = nullptr;
public:
NoiseTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
NoiseTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
void add(uint32_t dataId, const NoiseData& data);
void remove(uint32_t dataId);

13
src/tools/noisetool2/NoiseTool2.cpp
View File

@ -7,8 +7,8 @@
#include "NodeGraph.h"
#include "voxel/MaterialColor.h"
NoiseTool2::NoiseTool2(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider) {
NoiseTool2::NoiseTool2(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
}
void NoiseTool2::onRenderUI() {
@ -55,9 +55,10 @@ core::AppState NoiseTool2::onInit() {
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
NoiseTool2 app(filesystem, eventBus, timeProvider);
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
NoiseTool2 app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/noisetool2/NoiseTool2.h
View File

@ -16,7 +16,7 @@ private:
bool _windowOpened = true;
public:
NoiseTool2(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
NoiseTool2(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
core::AppState onConstruct() override;

13
src/tools/shadertool/ShaderTool.cpp
View File

@ -14,8 +14,8 @@
#include "Generator.h"
#include "Parser.h"
ShaderTool::ShaderTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider, 0) {
ShaderTool::ShaderTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "shadertool");
}
@ -206,9 +206,10 @@ core::AppState ShaderTool::onRunning() {
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
ShaderTool app(filesystem, eventBus, timeProvider);
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
ShaderTool app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/shadertool/ShaderTool.h
View File

@ -24,7 +24,7 @@ protected:
bool parse(const std::string& src, bool vertex);
public:
ShaderTool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
ShaderTool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onConstruct() override;
core::AppState onRunning() override;

7
src/tools/shapetool/ShapeTool.cpp
View File

@ -23,8 +23,8 @@
* LODs: Start with low level mesh - World Generator must be able to get a step-offset
* That way we have "something" quite fast
*/
ShapeTool::ShapeTool(const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider), _camera(), _meshPool(meshPool) {
ShapeTool::ShapeTool(const metric::MetricPtr& metric, const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider), _camera(), _meshPool(meshPool) {
init(ORGANISATION, "shapetool");
}
@ -203,6 +203,7 @@ int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
ShapeTool app(meshPool, filesystem, eventBus, timeProvider);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
ShapeTool app(metric, meshPool, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/shapetool/ShapeTool.h
View File

@ -46,7 +46,7 @@ protected:
void afterRootWidget() override;
public:
ShapeTool(const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
ShapeTool(const metric::MetricPtr& metric, const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
~ShapeTool();
core::AppState onConstruct() override;

13
src/tools/uitool/UITool.cpp
View File

@ -7,8 +7,8 @@
#include "ui/turbobadger/FontUtil.h"
#include "io/Filesystem.h"
UITool::UITool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(filesystem, eventBus, timeProvider, 0) {
UITool::UITool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider) :
Super(metric, filesystem, eventBus, timeProvider) {
init(ORGANISATION, "uitool");
}
@ -66,9 +66,10 @@ core::AppState UITool::onCleanup() {
}
int main(int argc, char *argv[]) {
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
UITool app(filesystem, eventBus, timeProvider);
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
UITool app(metric, filesystem, eventBus, timeProvider);
return app.startMainLoop(argc, argv);
}

2
src/tools/uitool/UITool.h
View File

@ -17,7 +17,7 @@ private:
DummyRenderer _renderer;
tb::TBWidget _root;
public:
UITool(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
UITool(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider);
core::AppState onInit() override;
core::AppState onRunning() override;

7
src/tools/voxedit/VoxEdit.cpp
View File

@ -22,8 +22,8 @@
#define COMMAND_CALL(command, call, help) core::Command::registerCommand(command, [this] (const core::CmdArgs& args) {call;}).setHelp(help)
#define COMMAND_MAINWINDOW_EVENT(command, help) core::Command::registerCommand(command, [this] (const core::CmdArgs& args) {tb::TBWidgetEvent event(tb::EVENT_TYPE_CUSTOM);event.ref_id = TBIDC(command);_mainWindow->InvokeEvent(event);}).setHelp(help)
VoxEdit::VoxEdit(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::MeshPoolPtr& meshPool) :
Super(filesystem, eventBus, timeProvider), _mainWindow(nullptr), _meshPool(meshPool) {
VoxEdit::VoxEdit(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::MeshPoolPtr& meshPool) :
Super(metric, filesystem, eventBus, timeProvider), _mainWindow(nullptr), _meshPool(meshPool) {
init(ORGANISATION, "voxedit");
}
@ -321,6 +321,7 @@ int main(int argc, char *argv[]) {
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const video::MeshPoolPtr& meshPool = std::make_shared<video::MeshPool>();
VoxEdit app(filesystem, eventBus, timeProvider, meshPool);
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
VoxEdit app(metric, filesystem, eventBus, timeProvider, meshPool);
return app.startMainLoop(argc, argv);
}

2
src/tools/voxedit/VoxEdit.h
View File

@ -20,7 +20,7 @@ private:
void update();
public:
VoxEdit(const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::MeshPoolPtr& meshPool);
VoxEdit(const metric::MetricPtr& metric, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const video::MeshPoolPtr& meshPool);
std::string fileDialog(OpenFileMode mode, const std::string& filter) override;

17
src/tools/worldrenderertool/WorldRendererTool.cpp
View File

@ -15,8 +15,8 @@
#include "frontend/Movement.h"
#include "voxel/MaterialColor.h"
WorldRendererTool::WorldRendererTool(const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const voxel::WorldPtr& world) :
Super(filesystem, eventBus, timeProvider), _camera(), _meshPool(meshPool), _worldRenderer(world), _world(world) {
WorldRendererTool::WorldRendererTool(const metric::MetricPtr& metric, const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const voxel::WorldPtr& world) :
Super(metric, filesystem, eventBus, timeProvider), _camera(), _meshPool(meshPool), _worldRenderer(world), _world(world) {
init(ORGANISATION, "worldrenderertool");
_world->setClientData(true);
}
@ -232,11 +232,12 @@ void WorldRendererTool::reset(const voxel::WorldContext& ctx) {
}
int main(int argc, char *argv[]) {
const video::MeshPoolPtr meshPool = std::make_shared<video::MeshPool>();
const core::EventBusPtr eventBus = std::make_shared<core::EventBus>();
const voxel::WorldPtr world = std::make_shared<voxel::World>();
const io::FilesystemPtr filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr timeProvider = std::make_shared<core::TimeProvider>();
WorldRendererTool app(meshPool, filesystem, eventBus, timeProvider, world);
const video::MeshPoolPtr& meshPool = std::make_shared<video::MeshPool>();
const core::EventBusPtr& eventBus = std::make_shared<core::EventBus>();
const voxel::WorldPtr& world = std::make_shared<voxel::World>();
const io::FilesystemPtr& filesystem = std::make_shared<io::Filesystem>();
const core::TimeProviderPtr& timeProvider = std::make_shared<core::TimeProvider>();
const metric::MetricPtr& metric = std::make_shared<metric::Metric>();
WorldRendererTool app(metric, meshPool, filesystem, eventBus, timeProvider, world);
return app.startMainLoop(argc, argv);
}

2
src/tools/worldrenderertool/WorldRendererTool.h
View File

@ -47,7 +47,7 @@ protected:
void beforeUI() override;
public:
WorldRendererTool(const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const voxel::WorldPtr& world);
WorldRendererTool(const metric::MetricPtr& metric, const video::MeshPoolPtr& meshPool, const io::FilesystemPtr& filesystem, const core::EventBusPtr& eventBus, const core::TimeProviderPtr& timeProvider, const voxel::WorldPtr& world);
~WorldRendererTool();
void reset(const voxel::WorldContext& ctx);