redstrate/prism
Archived
1
Fork 0
Code Activity

Change window handles into opaque pointers

Browse source
This commit is contained in:
redstrate 2021-10-12 10:22:16 -04:00
parent 91cf44a0de
commit c6bc56d033
18 changed files with 195 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
engine/core/include/engine.hpp
View file

@ -72,7 +72,7 @@ namespace prism {
/** Call to begin rendering for a window.
@param index The index of the window to begin rendering for.
*/
void render(int index);
void render(platform::window_ptr index);
void end_frame();
@ -176,18 +176,27 @@ namespace prism {
@param identifier The identifier of the new window.
@param extent The extent of the window.
*/
void add_window(void* native_handle, int identifier, prism::Extent extent);
void add_window(void* native_handle, platform::window_ptr window, prism::Extent extent);
/** Removes the window from engine management. Should be called before the window is actually closed.
@param identifier The identifier of the window to remove.
*/
void remove_window(int identifier);
void remove_window(platform::window_ptr identifier);
platform::window_ptr get_main_window() {
return windows[0]->identifier;
}
/** Called when the window has changed size.
@param identifier The window that has been resized.
@param extent The new extent of the window.
*/
void resize(int identifier, prism::Extent extent);
void resize(platform::window_ptr identifier, prism::Extent extent);
/** Called when the window has moved.
*
*/
void move(platform::window_ptr identifier);
/** Called when a key has been pressed.
@param keyCode A platform-specific key code.
@ -306,7 +315,7 @@ namespace prism {
std::map<std::string, Scene*> path_to_scene;
struct Window {
int identifier = -1;
platform::window_ptr identifier = nullptr;
prism::Extent extent;
bool quit_requested = false;
@ -315,7 +324,7 @@ namespace prism {
std::vector<Window*> windows;
Window* get_window(const int identifier) {
Window* get_window(const platform::window_ptr identifier) {
for(auto& window : windows) {
if(window->identifier == identifier)
return window;

10
engine/core/include/imgui_backend.hpp
View file

@ -3,6 +3,8 @@
#include <string_view>
#include <filesystem>
#include "platform.hpp"
namespace prism {
class imgui_backend {
public:
@ -10,21 +12,23 @@ namespace prism {
void begin_frame(float delta_time);
void render(int index);
void render();
void process_move(platform::window_ptr identifier);
void process_mouse_down(int button);
void process_key_down(unsigned int key_code);
void process_key_up(unsigned int key_code);
void process_text_input(const std::string_view string);
void process_text_input(std::string_view string);
/**Opens a file dialog to select a file. This will not block.
@param existing Whether or not to limit to existing files.
@param returnFunction The callback function when a file is selected or the dialog is cancelled. An empy string is returned when cancelled.
@param openDirectory Whether or not to allow selecting directories as well.
*/
void open_dialog(const bool existing, std::function<void(std::string)> returnFunction, bool openDirectory = false);
void open_dialog(bool existing, std::function<void(std::string)> returnFunction, bool openDirectory = false);
/**Opens a file dialog to select a save location for a file. This will not block.
@param returnFunction The callback function when a file is selected or the dialog is cancelled. An empy string is returned when cancelled.

46
engine/core/src/engine.cpp
View file

@ -377,39 +377,39 @@ void engine::save_prefab(const Object root, const std::string_view path) {
out << j;
}
void engine::add_window(void* native_handle, const int identifier, const prism::Extent extent) {
void engine::add_window(void* native_handle, const platform::window_ptr window_ptr, const prism::Extent extent) {
Expects(native_handle != nullptr);
Expects(identifier >= 0);
if(identifier == 0) {
renderer = std::make_unique<prism::renderer>(gfx);
}
const auto drawable_extent = platform::get_window_drawable_size(identifier);
gfx->initialize_view(native_handle, identifier, drawable_extent.width, drawable_extent.height);
auto* window = new Window();
windows.push_back(window);
window->identifier = identifier;
window->identifier = window_ptr;
if(platform::is_main_window(window_ptr)) {
renderer = std::make_unique<prism::renderer>(gfx);
ImGuiViewport* main_viewport = ImGui::GetMainViewport();
main_viewport->PlatformHandle = ::engine->get_main_window();
}
const auto drawable_extent = platform::get_window_drawable_size(window_ptr);
gfx->initialize_view(native_handle, window_ptr, drawable_extent.width, drawable_extent.height);
window->extent = extent;
window->render_target = renderer->allocate_render_target(drawable_extent);
render_ready = true;
}
void engine::remove_window(const int identifier) {
Expects(identifier >= 0);
void engine::remove_window(const platform::window_ptr identifier) {
utility::erase_if(windows, [identifier](Window*& w) {
return w->identifier == identifier;
});
}
void engine::resize(const int identifier, const prism::Extent extent) {
Expects(identifier >= 0);
void engine::resize(const platform::window_ptr identifier, const prism::Extent extent) {
auto window = get_window(identifier);
if (window == nullptr)
return;
@ -422,6 +422,10 @@ void engine::resize(const int identifier, const prism::Extent extent) {
renderer->resize_render_target(*window->render_target, drawable_extent);
}
void engine::move(const platform::window_ptr identifier) {
imgui->process_move(identifier);
}
void engine::process_key_down(const unsigned int keyCode) {
Expects(keyCode >= 0);
@ -705,17 +709,15 @@ void engine::update_scene(Scene& scene) {
}
}
void engine::render(const int index) {
Expects(index >= 0);
void engine::render(const platform::window_ptr index) {
auto window = get_window(index);
if(window == nullptr)
return;
GFXCommandBuffer* commandbuffer = gfx->acquire_command_buffer(true);
if(index == 0) {
imgui->render(0);
if(platform::is_main_window(index)) {
imgui->render();
app->render(commandbuffer);
}

48
engine/core/src/imgui_backend.cpp
View file

@ -94,9 +94,6 @@ imgui_backend::imgui_backend() {
break;
}
ImGuiViewport* main_viewport = ImGui::GetMainViewport();
main_viewport->PlatformHandle = new int(0);
ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
ImGuiPlatformMonitor monitor = {};
@ -114,50 +111,59 @@ imgui_backend::imgui_backend() {
platform_io.Monitors.push_back(monitor);
platform_io.Platform_CreateWindow = [](ImGuiViewport* viewport) {
viewport->PlatformHandle = new int(platform::open_window("", {viewport->Pos, viewport->Size}, WindowFlags::Borderless));
viewport->Flags = ImGuiViewportFlags_NoDecoration;
viewport->PlatformHandle = platform::open_window("",
{viewport->Pos, viewport->Size}, WindowFlags::Borderless);
};
platform_io.Platform_DestroyWindow = [](ImGuiViewport* viewport) {
platform::close_window(*(int*)viewport->PlatformHandle);
platform::close_window(viewport->PlatformHandle);
};
platform_io.Platform_ShowWindow = [](ImGuiViewport*) {};
platform_io.Platform_SetWindowPos = [](ImGuiViewport* viewport, const ImVec2 pos) {
platform::set_window_position(*(int*)viewport->PlatformHandle, pos);
platform::set_window_position(viewport->PlatformHandle, pos);
};
platform_io.Platform_GetWindowPos = [](ImGuiViewport* viewport) {
auto [x, y] = platform::get_window_position(*(int*)viewport->PlatformHandle);
auto [x, y] = platform::get_window_position(viewport->PlatformHandle);
return ImVec2(x, y);
};
platform_io.Platform_SetWindowSize = [](ImGuiViewport* viewport, const ImVec2 size) {
platform::set_window_size(*(int*)viewport->PlatformHandle, size);
platform::set_window_size(viewport->PlatformHandle, size);
};
platform_io.Platform_GetWindowSize = [](ImGuiViewport* viewport) {
auto [x, y] = platform::get_window_size(*(int*)viewport->PlatformHandle);
auto [x, y] = platform::get_window_size(viewport->PlatformHandle);
return ImVec2(x, y);
};
platform_io.Platform_SetWindowFocus = [](ImGuiViewport* viewport) {
platform::set_window_focused(*(int*)viewport->PlatformHandle);
platform::set_window_focused(viewport->PlatformHandle);
};
platform_io.Platform_GetWindowFocus = [](ImGuiViewport* viewport) {
return platform::is_window_focused(*(int*)viewport->PlatformHandle);
return platform::is_window_focused(viewport->PlatformHandle);
};
platform_io.Platform_GetWindowMinimized = [](ImGuiViewport*) {
return false;
};
platform_io.Platform_SetWindowTitle = [](ImGuiViewport* viewport, const char* title) {
platform::set_window_title(*(int*)viewport->PlatformHandle, title);
platform_io.Platform_SetWindowTitle = [](ImGuiViewport* viewport, const char* title) {
platform::set_window_title(viewport->PlatformHandle, title);
};
}
void imgui_backend::process_move(platform::window_ptr identifier) {
auto viewport = ImGui::FindViewportByPlatformHandle(identifier);
if(viewport != nullptr)
viewport->PlatformRequestMove = true;
}
void imgui_backend::begin_frame(const float delta_time) {
ImGuiIO& io = ImGui::GetIO();
@ -172,8 +178,8 @@ void imgui_backend::begin_frame(const float delta_time) {
}
}
const auto [width, height] = platform::get_window_size(0);
const auto [dw, dh] = platform::get_window_drawable_size(0);
const auto [width, height] = platform::get_window_size(::engine->get_main_window());
const auto [dw, dh] = platform::get_window_drawable_size(::engine->get_main_window());
io.DisplaySize = ImVec2(width, height);
io.DisplayFramebufferScale = ImVec2((float)dw / width, (float)dh / height);
@ -248,15 +254,13 @@ void imgui_backend::begin_frame(const float delta_time) {
dialog_function(save_dialog_data);
ImGui::EndPopup();
}
ImGui::ShowMetricsWindow();
}
void imgui_backend::render(int index) {
Expects(index >= 0);
if(index == 0) {
ImGui::EndFrame();
ImGui::Render();
}
void imgui_backend::render() {
ImGui::EndFrame();
ImGui::Render();
}
void imgui_backend::process_key_down(unsigned int key_code) {

2
engine/core/src/input.cpp
View file

@ -18,7 +18,7 @@ void input_system::update() {
const auto& [x, y] = platform::get_cursor_position();
auto& [oldX, oldY] = _last_cursor_position;
const auto [width, height] = platform::get_window_size(0);
const auto [width, height] = platform::get_window_size(::engine->get_main_window());
float xDelta = (x - oldX) / (float)width;
float yDelta = (y - oldY) / (float)height;

9
engine/gfx/public/gfx.hpp
View file

@ -5,6 +5,7 @@
#include <variant>
#include "shadercompiler.hpp"
#include "platform.hpp"
class GFXBuffer;
class GFXPipeline;
@ -309,15 +310,15 @@ public:
virtual bool initialize([[maybe_unused]] const GFXCreateInfo& createInfo) { return false; }
virtual void initialize_view([[maybe_unused]] void* native_handle,
[[maybe_unused]] const int identifier,
[[maybe_unused]] const platform::window_ptr identifier,
[[maybe_unused]] const uint32_t width,
[[maybe_unused]] const uint32_t height) {}
virtual void recreate_view([[maybe_unused]] const int identifier,
virtual void recreate_view([[maybe_unused]] const platform::window_ptr identifier,
[[maybe_unused]] const uint32_t width,
[[maybe_unused]] const uint32_t height) {}
virtual void remove_view([[maybe_unused]] const int identifier) {}
virtual void remove_view([[maybe_unused]] const platform::window_ptr identifier) {}
// buffer operations
virtual GFXBuffer* create_buffer([[maybe_unused]] void* data,
@ -362,5 +363,5 @@ public:
virtual GFXCommandBuffer* acquire_command_buffer(bool for_presentation_use = false) { return nullptr; }
virtual void submit([[maybe_unused]] GFXCommandBuffer* command_buffer,
[[maybe_unused]] const int window = -1) {}
[[maybe_unused]] const platform::window_ptr window = nullptr) {}
};

8
engine/gfx/vulkan/include/gfx_vulkan.hpp
View file

@ -9,7 +9,7 @@
#include "gfx_vulkan_constants.hpp"
struct NativeSurface {
int identifier = -1;
platform::window_ptr identifier = nullptr;
uint32_t surfaceWidth = -1, surfaceHeight = -1;
@ -44,8 +44,8 @@ public:
bool initialize(const GFXCreateInfo& info) override;
void initialize_view(void* native_handle, int identifier, uint32_t width, uint32_t height) override;
void recreate_view(int identifier, uint32_t width, uint32_t height) override;
void initialize_view(void* native_handle, platform::window_ptr identifier, uint32_t width, uint32_t height) override;
void recreate_view(platform::window_ptr identifier, uint32_t width, uint32_t height) override;
// buffer operations
GFXBuffer* create_buffer(void* data, GFXSize size, bool dynamic_data, GFXBufferUsage usage) override;
@ -78,7 +78,7 @@ public:
GFXCommandBuffer* acquire_command_buffer(bool for_presentation_use) override;
void submit(GFXCommandBuffer* command_buffer, int identifier) override;
void submit(GFXCommandBuffer* command_buffer, platform::window_ptr identifier) override;
private:
void createInstance(std::vector<const char*> layers, std::vector<const char*> extensions);

10
engine/gfx/vulkan/src/gfx_vulkan.cpp
View file

@ -228,7 +228,7 @@ bool GFXVulkan::initialize(const GFXCreateInfo& info) {
return true;
}
void GFXVulkan::initialize_view(void* native_handle, const int identifier, const uint32_t width, const uint32_t height) {
void GFXVulkan::initialize_view(void* native_handle, const platform::window_ptr identifier, const uint32_t width, const uint32_t height) {
vkDeviceWaitIdle(device);
auto surface = new NativeSurface();
@ -242,7 +242,7 @@ void GFXVulkan::initialize_view(void* native_handle, const int identifier, const
native_surfaces.push_back(surface);
}
void GFXVulkan::recreate_view(const int identifier, const uint32_t width, const uint32_t height) {
void GFXVulkan::recreate_view(const platform::window_ptr identifier, const uint32_t width, const uint32_t height) {
vkDeviceWaitIdle(device);
NativeSurface* found_surface = nullptr;
@ -1198,7 +1198,7 @@ GFXCommandBuffer* GFXVulkan::acquire_command_buffer(bool for_presentation_use) {
return cmdbuf;
}
void GFXVulkan::submit(GFXCommandBuffer* command_buffer, const int identifier) {
void GFXVulkan::submit(GFXCommandBuffer* command_buffer, const platform::window_ptr identifier) {
NativeSurface* current_surface = nullptr;
for(auto surface : native_surfaces) {
if(surface->identifier == identifier)
@ -1206,7 +1206,7 @@ void GFXVulkan::submit(GFXCommandBuffer* command_buffer, const int identifier) {
}
uint32_t imageIndex = 0;
if(identifier != -1 && current_surface != nullptr) {
if(identifier != nullptr && current_surface != nullptr) {
vkWaitForFences(device, 1, &current_surface->inFlightFences[current_surface->currentFrame], VK_TRUE, std::numeric_limits<uint64_t>::max());
VkResult result = vkAcquireNextImageKHR(device, current_surface->swapchain, std::numeric_limits<uint64_t>::max(), current_surface->imageAvailableSemaphores[current_surface->currentFrame], VK_NULL_HANDLE, &imageIndex);
@ -1653,7 +1653,7 @@ void GFXVulkan::submit(GFXCommandBuffer* command_buffer, const int identifier) {
vkEndCommandBuffer(cmd);
if(identifier == -1) {
if(identifier == nullptr) {
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;

53
engine/platform/include/platform.hpp
View file

@ -65,6 +65,8 @@ enum class PlatformTheme {
};
namespace platform {
using window_ptr = void*;
/// Returns a human readable platform name, e.g. Linux.
const char* get_name();
@ -72,7 +74,7 @@ namespace platform {
PlatformTheme get_theme();
/// Queries whether or not the platform supports a certain feature.
bool supports_feature(const PlatformFeature feature);
bool supports_feature(PlatformFeature feature);
/** Opens a new window.
@param title The title of the window.
@ -82,22 +84,25 @@ namespace platform {
@note On platforms that do not support the Windowing feature, calling open_window more than once is not supported. In this case, the same identifier is returned.
@return A valid window identifier.
*/
int open_window(const std::string_view title, const prism::Rectangle rect, const WindowFlags flags);
window_ptr open_window(std::string_view title, prism::Rectangle rect, WindowFlags flags);
bool is_main_window(window_ptr index);
// for vulkan usage
void* create_native_surface(int index, void* instance);
void* create_native_surface(window_ptr window, void* instance);
std::vector<const char*> get_native_surface_extension();
/** Closes a window.
@param index The window to close.
*/
void close_window(const int index);
void close_window(window_ptr window);
/// Forces the platform to quit the application. This is not related to Engine::quit().
void force_quit();
/// Gets the content scale for the window. 1.0 would be 1x scale, 2.0 would be 2x scale, etc.
float get_window_dpi(const int index);
float get_window_dpi(window_ptr window);
/// Gets the content scale for the monitor. 1.0 would be 1x scale, 2.0 would be 2x scale, etc.
float get_monitor_dpi();
@ -109,34 +114,34 @@ namespace platform {
prism::Rectangle get_monitor_work_area();
/// Get the window position.
prism::Offset get_window_position(const int index);
prism::Offset get_window_position(window_ptr window);
/// Get the window size, note that in hidpi scenarios this is the non-scaled resolution.
prism::Extent get_window_size(const int index);
prism::Extent get_window_size(window_ptr window);
/// Get the window's drawable size. Always use this instead of manually multiplying the window size by the content scale.
prism::Extent get_window_drawable_size(const int index);
prism::Extent get_window_drawable_size(window_ptr window);
/// Query whether or not the window is focused.
bool is_window_focused(const int index);
bool is_window_focused(window_ptr window);
/// If possible, try to manually focus the window.
void set_window_focused(const int index);
void set_window_focused(window_ptr window);
/// Sets the window position to the offset provided.
void set_window_position(const int index, const prism::Offset offset);
void set_window_position(window_ptr window, prism::Offset offset);
/// Sets the window to the specified size. The platform will handle the subsequent resize events.
void set_window_size(const int index, const prism::Extent extent);
void set_window_size(window_ptr window, prism::Extent extent);
/// Sets the window title.
void set_window_title(const int index, const std::string_view title);
void set_window_title(window_ptr window, std::string_view title);
/// Queries whether or not the button is currently pressed.
bool get_key_down(const InputButton key);
bool get_key_down(InputButton key);
/// If available for the InputButton, returns the platform-specific keycode.
int get_keycode(const InputButton key);
int get_keycode(InputButton key);
/// Returns the current moue cursor position, relative to the window.
prism::Offset get_cursor_position();
@ -145,7 +150,7 @@ namespace platform {
prism::Offset get_screen_cursor_position();
/// Queries whether or not the mouse button requested is pressed or not.
bool get_mouse_button_down(const int button);
bool get_mouse_button_down(int button);
/// Returns the current mouse wheel delta on both axes.
std::tuple<float, float> get_wheel_delta();
@ -157,22 +162,10 @@ namespace platform {
std::tuple<float, float> get_left_stick_position();
/// On platforms that support moue capture, this will lock the mouse cursor to the window and hide it.
void capture_mouse(const bool capture);
void capture_mouse(bool capture);
// TODO: right now the OS intercepting and saying "We dont want text input anymore" ala software keyboards is NOT supported yet
void begin_text_input();
void end_text_input();
/**Translates a virtual keycode to it's character equivalent.
@note Example: translateKey(0x01) = 'a'; 0x01 in this example is a platform and language specific keycode for a key named 'a'.
@return A char pointer to the string if translated correctly.
@note Manually freeing the string returned is not needed.
*/
char* translate_keycode(const unsigned int keycode);
/// Mute standard output
void mute_output();
/// Unmute standard output
void unmute_output();
}

2
engine/renderer/include/imguipass.hpp
View file

@ -17,7 +17,7 @@ public:
void create_render_target_resources(RenderTarget& target) override;
void render_post(GFXCommandBuffer* command_buffer, RenderTarget& target, const int index) override;
void render_post(GFXCommandBuffer* command_buffer, RenderTarget& target, const platform::window_ptr index) override;
private:
void load_font(const std::string_view filename);

3
engine/renderer/include/pass.hpp
View file

@ -1,6 +1,7 @@
#pragma once
#include "common.hpp"
#include "platform.hpp"
class GFXCommandBuffer;
class Scene;
@ -24,7 +25,7 @@ public:
[[maybe_unused]] GFXCommandBuffer* commandBuffer) {}
virtual void render_post([[maybe_unused]] GFXCommandBuffer* commandBuffer,
[[maybe_unused]] RenderTarget& target,
[[maybe_unused]] int index) {}
[[maybe_unused]] platform::window_ptr index) {}
virtual GFXTexture* get_requested_texture([[maybe_unused]] PassTextureType type) { return nullptr; }
};

3
engine/renderer/include/renderer.hpp
View file

@ -13,6 +13,7 @@
#include "path.hpp"
#include "shadercompiler.hpp"
#include "rendertarget.hpp"
#include "platform.hpp"
namespace ui {
class Screen;
@ -59,7 +60,7 @@ namespace prism {
int elementOffset = 0;
};
void render(GFXCommandBuffer* command_buffer, Scene* scene, RenderTarget& target, int index);
void render(GFXCommandBuffer* command_buffer, Scene* scene, RenderTarget& target, platform::window_ptr index);
void render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera,
prism::Extent extent, RenderTarget& target, controller_continuity &continuity);

11
engine/renderer/src/imguipass.cpp
View file

@ -70,16 +70,15 @@ void ImGuiPass::create_render_target_resources(RenderTarget& target) {
}
}
void ImGuiPass::render_post(GFXCommandBuffer* command_buffer, RenderTarget& target, const int index) {
void ImGuiPass::render_post(GFXCommandBuffer* command_buffer, RenderTarget& target, const platform::window_ptr index) {
ImDrawData* draw_data = nullptr;
if(index == 0) {
if(platform::is_main_window(index)) {
draw_data = ImGui::GetDrawData();
} else {
auto& io = ImGui::GetPlatformIO();
for(int i = 1; i < io.Viewports.size(); i++) {
if((io.Viewports[i]->Flags & ImGuiViewportFlags_Minimized) == 0) {
auto platform_handle = (int*)io.Viewports[i]->PlatformHandle;
if(platform_handle != nullptr && *platform_handle == index)
if(io.Viewports[i]->PlatformHandle == index)
draw_data = io.Viewports[i]->DrawData;
}
}
@ -159,8 +158,8 @@ void ImGuiPass::load_font(const std::string_view filename) {
font_file->read_all();
io.Fonts->AddFontFromMemoryTTF(font_file->cast_data<unsigned char>(), font_file->size(), 15.0 * platform::get_window_dpi(0));
ImGui::GetIO().FontGlobalScale = 1.0 / platform::get_window_dpi(0);
io.Fonts->AddFontFromMemoryTTF(font_file->cast_data<unsigned char>(), font_file->size(), 15.0 * platform::get_window_dpi(engine->get_main_window()));
ImGui::GetIO().FontGlobalScale = 1.0 / platform::get_window_dpi(engine->get_main_window());
} else {
prism::log("Failed to load font file for imgui!");
return;

11
engine/renderer/src/renderer.cpp
View file

@ -20,7 +20,6 @@
#include "dofpass.hpp"
#include "frustum.hpp"
#include "shadercompiler.hpp"
#include "asset.hpp"
#include "debug.hpp"
using prism::renderer;
@ -35,12 +34,6 @@ struct GlyphInstance {
uint32_t position = 0, index = 0, instance = 0;
};
struct GylphMetric {
uint32_t x0_y0, x1_y1;
float xoff, yoff;
float xoff2, yoff2;
};
struct StringInstance {
uint32_t xy;
};
@ -184,11 +177,11 @@ void renderer::recreate_all_render_targets() {
}
void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarget& target, int index) {
void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarget& target, platform::window_ptr index) {
const auto extent = target.extent;
const auto render_extent = target.get_render_extent();
if(index > 0) {
if(!platform::is_main_window(index)) {
GFXRenderPassBeginInfo beginInfo = {};
beginInfo.render_area.extent = render_extent;

119
platforms/sdl/main.cpp.in
View file

@ -17,30 +17,22 @@
@APP_CLASS@* app = nullptr;
GFX* gfx_interface = nullptr;
struct Window {
int identifier = 0;
SDL_Window* window = nullptr;
std::vector<SDL_Window*> windows;
SDL_Window* main_window = nullptr;
bool operator==(const Window& b) {
return identifier == b.identifier && window == b.window;
}
};
std::vector<Window> windows;
Window* get_window(const int index) {
SDL_Window* get_window(const platform::window_ptr index) {
for(auto& window : windows) {
if(window.identifier == index)
return &window;
if(window == index)
return window;
}
return nullptr;
}
Window* get_window_by_sdl_id(const Uint32 id) {
SDL_Window* get_window_by_sdl_id(const Uint32 id) {
for(auto& window : windows) {
if(SDL_GetWindowID(window.window) == id)
return &window;
if(SDL_GetWindowID(window) == id)
return window;
}
return nullptr;
@ -85,9 +77,8 @@ bool platform::supports_feature(const PlatformFeature feature) {
return false;
}
int platform::open_window(const std::string_view title, const prism::Rectangle rect, const WindowFlags flags) {
platform::window_ptr platform::open_window(const std::string_view title, const prism::Rectangle rect, const WindowFlags flags) {
auto& win = windows.emplace_back();
win.identifier = windows.size() - 1;
int sdl_flags = SDL_WINDOW_VULKAN;
if(flags == WindowFlags::Borderless)
@ -95,36 +86,56 @@ int platform::open_window(const std::string_view title, const prism::Rectangle r
if(flags == WindowFlags::Resizable)
sdl_flags |= SDL_WINDOW_RESIZABLE;
auto resolution = platform::get_monitor_resolution();
int real_x = rect.offset.x;
int real_y = rect.offset.y;
if(rect.offset.x == -1 && rect.offset.y == -1) {
if(rect.offset.x <= -1 || rect.offset.x >= resolution.extent.width)
real_x = SDL_WINDOWPOS_CENTERED;
if(rect.offset.y <= -1 || rect.offset.x >= resolution.extent.height)
real_y = SDL_WINDOWPOS_CENTERED;
}
win.window = SDL_CreateWindow(title.data(), real_x, real_y, rect.extent.width, rect.extent.height, sdl_flags);
int real_width = rect.extent.width;
int real_height = rect.extent.height;
engine->add_window((void*)&win, win.identifier, rect.extent);
if(rect.extent.width <= -1 || rect.extent.width >= resolution.extent.width)
real_width = 640;
if(rect.extent.height <= -1 || rect.extent.height >= resolution.extent.height)
real_height = 480;
win = SDL_CreateWindow(title.data(), real_x, real_y, real_width, real_height, sdl_flags);
if(windows.size() == 1)
main_window = win;
engine->add_window((void*)win, win, rect.extent);
app->initialize_render();
return win.identifier;
return win;
}
void platform::close_window(const int index) {
bool platform::is_main_window(platform::window_ptr index) {
return index == main_window;
}
void platform::close_window(const platform::window_ptr index) {
auto window = get_window(index);
engine->remove_window(window->identifier);
engine->remove_window(index);
SDL_DestroyWindow(window->window);
SDL_DestroyWindow(window);
utility::erase(windows, *window);
utility::erase(windows, window);
}
void platform::force_quit() {
SDL_Quit();
}
float platform::get_window_dpi(const int index) {
float platform::get_window_dpi(const platform::window_ptr index) {
return 1.0;
}
@ -143,59 +154,59 @@ prism::Rectangle platform::get_monitor_work_area() {
return platform::get_monitor_resolution();
}
prism::Offset platform::get_window_position(const int index) {
prism::Offset platform::get_window_position(const platform::window_ptr index) {
auto window = get_window(index);
int x, y;
SDL_GetWindowPosition(window->window, &x, &y);
SDL_GetWindowPosition(window, &x, &y);
return {(int32_t)x, (int32_t)y};
}
prism::Extent platform::get_window_size(const int index) {
prism::Extent platform::get_window_size(const platform::window_ptr index) {
auto window = get_window(index);
int width, height;
SDL_GetWindowSize(window->window, &width, &height);
SDL_GetWindowSize(window, &width, &height);
return {(uint32_t)width, (uint32_t)height};
}
prism::Extent platform::get_window_drawable_size(const int index) {
prism::Extent platform::get_window_drawable_size(const platform::window_ptr index) {
auto window = get_window(index);
int width, height;
SDL_GetWindowSize(window->window, &width, &height);
SDL_GetWindowSize(window, &width, &height);
return {(uint32_t)width, (uint32_t)height};
}
bool platform::is_window_focused(const int index) {
bool platform::is_window_focused(const platform::window_ptr index) {
auto window = get_window(index);
return (SDL_GetWindowFlags(window->window) & SDL_WINDOW_INPUT_FOCUS) != 0;
return (SDL_GetWindowFlags(window) & SDL_WINDOW_INPUT_FOCUS) != 0;
}
void platform::set_window_focused(const int index) {
void platform::set_window_focused(const platform::window_ptr index) {
auto window = get_window(index);
SDL_RaiseWindow(window->window);
SDL_RaiseWindow(window);
}
void platform::set_window_position(const int index, const prism::Offset offset) {
void platform::set_window_position(const platform::window_ptr index, const prism::Offset offset) {
auto window = get_window(index);
SDL_SetWindowPosition(window->window, offset.x, offset.y);
SDL_SetWindowPosition(window, offset.x, offset.y);
}
void platform::set_window_size(const int index, const prism::Extent extent) {
void platform::set_window_size(const platform::window_ptr index, const prism::Extent extent) {
auto window = get_window(index);
SDL_SetWindowSize(window->window, extent.width, extent.height);
SDL_SetWindowSize(window, extent.width, extent.height);
}
void platform::set_window_title(const int index, const std::string_view title) {
void platform::set_window_title(const platform::window_ptr index, const std::string_view title) {
auto window = get_window(index);
SDL_SetWindowTitle(window->window, title.data());
SDL_SetWindowTitle(window, title.data());
}
bool platform::get_key_down(const InputButton key) {
@ -257,10 +268,6 @@ void platform::capture_mouse(const bool capture) {
SDL_CaptureMouse((SDL_bool)capture);
}
char* platform::translate_keycode(const unsigned int keycode) {
return const_cast<char*>(SDL_GetKeyName(SDL_GetKeyFromScancode((SDL_Scancode)keycode)));
}
void platform::begin_text_input() {
SDL_StartTextInput();
}
@ -269,10 +276,6 @@ void platform::end_text_input() {
SDL_StopTextInput();
}
void platform::mute_output() {}
void platform::unmute_output() {}
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
@ -332,7 +335,11 @@ int main(int argc, char* argv[]) {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
auto window = get_window_by_sdl_id(event.window.windowID);
if(window != nullptr)
engine->resize(window->identifier, {static_cast<uint32_t>(event.window.data1), static_cast<uint32_t>(event.window.data2)});
engine->resize(window, {static_cast<uint32_t>(event.window.data1), static_cast<uint32_t>(event.window.data2)});
} else if(event.window.event == SDL_WINDOWEVENT_MOVED) {
auto window = get_window_by_sdl_id(event.window.windowID);
if(window != nullptr)
engine->move(window);
} else if(event.window.event == SDL_WINDOWEVENT_CLOSE) {
engine->quit();
}
@ -358,7 +365,7 @@ int main(int argc, char* argv[]) {
engine->begin_frame(deltatime);
for(auto window : windows)
engine->render(window.identifier);
engine->render(window);
engine->end_frame();
}
@ -388,12 +395,12 @@ PlatformTheme platform::get_theme() {
}
#endif
void* platform::create_native_surface(int index, void* instance) {
void* platform::create_native_surface(platform::window_ptr index, void* instance) {
auto window = get_window(index);
VkSurfaceKHR surface;
SDL_Vulkan_CreateSurface(window->window, (VkInstance)instance, &surface);
SDL_Vulkan_CreateSurface(window, (VkInstance)instance, &surface);
return surface;
}

6
tools/common/src/commoneditor.cpp
View file

@ -653,7 +653,7 @@ void CommonEditor::createDockArea() {
void CommonEditor::drawViewport(Scene* scene) {
const auto size = ImGui::GetContentRegionAvail();
const auto real_size = ImVec2(size.x * platform::get_window_dpi(0), size.y * platform::get_window_dpi(0));
const auto real_size = ImVec2(size.x * platform::get_window_dpi(engine->get_main_window()), size.y * platform::get_window_dpi(0));
if(real_size.x <= 0 || real_size.y <= 0)
return;
@ -1045,8 +1045,8 @@ void CommonEditor::load_options() {
}
void CommonEditor::save_options() {
const auto& [x, y] = platform::get_window_position(0);
const auto& [width, height] = platform::get_window_size(0);
const auto& [x, y] = platform::get_window_position(engine->get_main_window());
const auto& [width, height] = platform::get_window_size(engine->get_main_window());
nlohmann::json j;
j["x"] = x;

5
tools/editor/src/prismeditor.cpp
View file

@ -3,10 +3,8 @@
#include <imgui.h>
#include <imgui_stdlib.h>
#include <imgui_internal.h>
#include <nlohmann/json.hpp>
#include "engine.hpp"
#include "imguipass.hpp"
#include "file.hpp"
#include "json_conversions.hpp"
#include "platform.hpp"
@ -14,7 +12,6 @@
#include "sceneeditor.hpp"
#include "materialeditor.hpp"
#include "prefabeditor.hpp"
#include "log.hpp"
std::string get_filename(const std::string path) {
return path.substr(path.find_last_of("/") + 1, path.length());
@ -168,7 +165,7 @@ void PrismEditor::open_asset(const prism::path path) {
void PrismEditor::renderEditor(GFXCommandBuffer* command_buffer) {
for(auto [id, render_target] : viewport_render_targets) {
engine->get_renderer()->render(command_buffer, render_target.scene, *render_target.target, -1);
engine->get_renderer()->render(command_buffer, render_target.scene, *render_target.target, nullptr);
}
}

2
tools/modelcompiler/src/modeleditor.cpp
View file

@ -489,7 +489,7 @@ void ModelEditor::drawUI() {
ImGui::Begin("mcompile", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBackground);
ImGui::SetWindowPos(ImVec2(0, 0));
ImGui::SetWindowSize(platform::get_window_size(0));
ImGui::SetWindowSize(platform::get_window_size(engine->get_main_window()));
if(ImGui::Button("Open model to compile...")) {
platform::open_dialog(true, [this](std::string path) {