init

framework/platform/platform.h

@@ -0,0 +1,202 @@
+/* Copyright (c) 2019-2025, Arm Limited and Contributors
+ * Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <core/platform/context.hpp>
+
+#include "apps.h"
+#include "common/optional.h"
+#include "common/utils.h"
+#include "common/vk_common.h"
+#include "platform/application.h"
+#include "platform/plugins/plugin.h"
+#include "platform/window.h"
+#include "rendering/render_context.h"
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+#	undef Success
+#endif
+
+namespace vkb
+{
+enum class ExitCode
+{
+	Success = 0, /* App executed as expected */
+	NoSample,    /* App should show help how to run a sample */
+	Help,        /* App should show help */
+	Close,       /* App has been requested to close at initialization */
+	FatalError   /* App encountered an unexpected error */
+};
+
+class Platform
+{
+  public:
+	Platform(const PlatformContext &context);
+
+	virtual ~Platform() = default;
+
+	/**
+	 * @brief Initialize the platform
+	 * @param plugins plugins available to the platform
+	 * @return An exit code representing the outcome of initialization
+	 */
+	virtual ExitCode initialize(const std::vector<Plugin *> &plugins);
+
+	/**
+	 * @brief Handles the main update and render loop
+	 * @return An exit code representing the outcome of the loop
+	 */
+	ExitCode main_loop();
+
+	/**
+	 * @brief Handles the update and render of a frame.
+	 * Called either from main_loop(), or from a platform-specific
+	 * frame-looping mechanism, typically tied to platform screen refeshes.
+	 * @return An exit code representing the outcome of the loop
+	 */
+	ExitCode main_loop_frame();
+
+	/**
+	 * @brief Runs the application for one frame
+	 */
+	void update();
+
+	/**
+	 * @brief Terminates the platform and the application
+	 * @param code Determines how the platform should exit
+	 */
+	virtual void terminate(ExitCode code);
+
+	/**
+	 * @brief Requests to close the platform at the next available point
+	 */
+	virtual void close();
+
+	std::string &get_last_error();
+
+	virtual void resize(uint32_t width, uint32_t height);
+
+	virtual void input_event(const InputEvent &input_event);
+
+	Window &get_window();
+
+	Application &get_app() const;
+
+	Application &get_app();
+
+	void set_last_error(const std::string &error);
+
+	template <class T>
+	T *get_plugin() const;
+
+	template <class T>
+	bool using_plugin() const;
+
+	void set_focus(bool focused);
+
+	void request_application(const apps::AppInfo *app);
+
+	bool app_requested();
+
+	bool start_app();
+
+	void force_simulation_fps(float fps);
+
+	// Force the application to always render even if it is not in focus
+	void force_render(bool should_always_render);
+
+	void disable_input_processing();
+
+	void set_window_properties(const Window::OptionalProperties &properties);
+
+	void on_post_draw(RenderContext &context);
+
+	static const uint32_t MIN_WINDOW_WIDTH;
+	static const uint32_t MIN_WINDOW_HEIGHT;
+
+  protected:
+	std::vector<Plugin *> active_plugins;
+
+	std::unordered_map<Hook, std::vector<Plugin *>> hooks;
+
+	std::unique_ptr<Window> window{nullptr};
+
+	std::unique_ptr<Application> active_app{nullptr};
+
+	virtual std::vector<spdlog::sink_ptr> get_platform_sinks();
+
+	/**
+	 * @brief Handles the creation of the window
+	 *
+	 * @param properties Preferred window configuration
+	 */
+	virtual void create_window(const Window::Properties &properties) = 0;
+
+	void register_hooks(Plugin *plugin);
+
+	void on_update(float delta_time);
+	void on_app_error(const std::string &app_id);
+	void on_app_start(const std::string &app_id);
+	void on_app_close(const std::string &app_id);
+	void on_platform_close();
+	void on_update_ui_overlay(vkb::Drawer &drawer);
+
+	Window::Properties window_properties;              /* Source of truth for window state */
+	bool               fixed_simulation_fps{false};    /* Delta time should be fixed with a fabricated value */
+	bool               always_render{false};           /* App should always render even if not in focus */
+	float              simulation_frame_time = 0.016f; /* A fabricated delta time */
+	bool               process_input_events{true};     /* App should continue processing input events */
+	bool               focused{true};                  /* App is currently in focus at an operating system level */
+	bool               close_requested{false};         /* Close requested */
+
+  protected:
+	std::vector<Plugin *> plugins;
+
+  private:
+	Timer timer;
+
+	const apps::AppInfo *requested_app{nullptr};
+
+	std::vector<std::string> arguments;
+
+	std::string last_error;
+
+	std::map<std::string, Plugin *> command_map;
+	std::map<std::string, Plugin *> option_map;
+};
+
+template <class T>
+bool Platform::using_plugin() const
+{
+	return !plugins::with_tags<T>(active_plugins).empty();
+}
+
+template <class T>
+T *Platform::get_plugin() const
+{
+	assert(using_plugin<T>() && "Plugin is not enabled but was requested");
+	const auto plugins = plugins::with_tags<T>(active_plugins);
+	return dynamic_cast<T *>(plugins[0]);
+}
+}        // namespace vkb