159 lines
4 KiB
C++
159 lines
4 KiB
C++
import preliminary;
|
|
import time;
|
|
import logger;
|
|
import renderer.system;
|
|
import renderer.frontend;
|
|
import surface.system;
|
|
import surface.events;
|
|
import surface.requests;
|
|
import ecs.entity;
|
|
import input.codes;
|
|
import ecs.registry;
|
|
import memory.scope;
|
|
import memory.reference;
|
|
import logger;
|
|
import math.vec2;
|
|
import app.system;
|
|
|
|
constexpr auto title = "TestWindow";
|
|
constexpr auto width = 800u;
|
|
constexpr auto height = 600u;
|
|
constexpr auto vsync = true;
|
|
constexpr auto visible = true;
|
|
|
|
template<class... Ts>
|
|
struct overloads: Ts...
|
|
{
|
|
using Ts::operator()...;
|
|
};
|
|
|
|
void renderer_debug_callback(
|
|
lt::renderer::IDebugger::MessageSeverity message_severity,
|
|
lt::renderer::IDebugger::MessageType message_type,
|
|
lt::renderer::IDebugger::MessageData data,
|
|
std::any &user_data
|
|
)
|
|
{
|
|
ignore = message_severity;
|
|
ignore = message_type;
|
|
ignore = user_data;
|
|
|
|
lt::log::trace("< Renderer > ==> {}", std::string { data.message });
|
|
}
|
|
|
|
auto main() -> i32
|
|
try
|
|
{
|
|
auto registry = lt::memory::create_ref<lt::ecs::Registry>();
|
|
auto surface_system = lt::surface::System { registry };
|
|
|
|
auto entity = registry->create_entity();
|
|
|
|
lt::log::trace("Creating surface component");
|
|
surface_system.create_surface_component(
|
|
entity,
|
|
lt::surface::SurfaceComponent::CreateInfo {
|
|
.title = title,
|
|
.position = { 500, 500 },
|
|
|
|
.resolution = { width, height },
|
|
.vsync = vsync,
|
|
.visible = visible,
|
|
}
|
|
);
|
|
|
|
auto &window = registry->get<lt::surface::SurfaceComponent>(entity);
|
|
|
|
const auto config = lt::renderer::System::Configuration {
|
|
.target_api = lt::renderer::Api::vulkan,
|
|
.max_frames_in_flight = 3u,
|
|
};
|
|
|
|
const auto debug_callback_info = lt::renderer::IDebugger::CreateInfo {
|
|
.severities = lt::renderer::IDebugger::MessageSeverity::all,
|
|
.types = lt::renderer::IDebugger::MessageType::all,
|
|
.callback = &renderer_debug_callback,
|
|
.user_data = nullptr,
|
|
};
|
|
|
|
const auto surface_entity = lt::ecs::Entity { registry, entity };
|
|
|
|
auto renderer_system = lt::renderer::System { lt::renderer::System::CreateInfo {
|
|
config,
|
|
registry,
|
|
surface_entity,
|
|
debug_callback_info,
|
|
} };
|
|
|
|
|
|
auto should_close = false;
|
|
const auto visitor = overloads {
|
|
[&](const lt::surface::ClosedEvent &) {
|
|
lt::log::info("Closing due to: Window X button pressed");
|
|
should_close = true;
|
|
},
|
|
[&](const lt::surface::MovedEvent &event) {
|
|
lt::log::info("Moved: {}", event.get_position());
|
|
},
|
|
[&](const lt::surface::ResizedEvent &event) {
|
|
lt::log::info("Resized: {}", event.get_size());
|
|
},
|
|
[&](const lt::surface::LostFocusEvent &) { lt::log::info("Lost focus"); },
|
|
[&](const lt::surface::GainFocusEvent &) { lt::log::info("Gain focus"); },
|
|
[&](const lt::surface::KeyPressedEvent &event) {
|
|
if (event.get_key() == lt::Key::escape)
|
|
{
|
|
lt::log::info("Closing due to: Escape key pressed");
|
|
should_close = true;
|
|
}
|
|
|
|
if (event.get_key() == lt::Key::q)
|
|
{
|
|
lt::log::info("Closing due to: Q key pressed");
|
|
should_close = true;
|
|
}
|
|
|
|
lt::log::info("Key pressed: {}", event.get_key());
|
|
},
|
|
[&](const lt::surface::KeyReleasedEvent &event) {
|
|
lt::log::info("Key released: {}", event.get_key());
|
|
},
|
|
[&](const lt::surface::PointerEvent &event) {
|
|
lt::log::info("Pointer: {}", event.get_position());
|
|
}
|
|
};
|
|
|
|
auto timer = lt::time::Timer {};
|
|
while (!should_close)
|
|
{
|
|
if (timer.elapsed_time() > std::chrono::milliseconds { 250 })
|
|
{
|
|
const auto [width, height] = window.get_resolution();
|
|
window.push_request(
|
|
lt::surface::ModifyResolutionRequest {
|
|
.resolution = { width + 50u, height + 50u },
|
|
}
|
|
);
|
|
|
|
lt::log::trace("mrrp");
|
|
timer.reset();
|
|
}
|
|
|
|
surface_system.tick({});
|
|
renderer_system.tick({});
|
|
|
|
for (const auto &event : window.peek_events())
|
|
{
|
|
std::visit(visitor, event);
|
|
}
|
|
}
|
|
}
|
|
catch (const std::exception &exp)
|
|
{
|
|
lt::log::critical("Aborting due to uncaught std::exception:");
|
|
lt::log::critical("\twhat: {}", exp.what());
|
|
}
|
|
catch (...)
|
|
{
|
|
lt::log::critical("Aborting due to uncaught non std::exception!");
|
|
}
|