198 lines
7.8 KiB
C++
198 lines
7.8 KiB
C++
// ----------------------------------------------------------------------------
|
|
// - Open3D: www.open3d.org -
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright (c) 2018-2023 www.open3d.org
|
|
// SPDX-License-Identifier: MIT
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "open3d/visualization/gui/Font.h"
|
|
#include "open3d/visualization/gui/Menu.h"
|
|
|
|
namespace open3d {
|
|
|
|
namespace geometry {
|
|
class Image;
|
|
}
|
|
|
|
namespace visualization {
|
|
|
|
namespace rendering {
|
|
class Renderer;
|
|
class View;
|
|
class Scene;
|
|
} // namespace rendering
|
|
|
|
namespace gui {
|
|
|
|
struct Theme;
|
|
class Window;
|
|
class WindowSystem;
|
|
|
|
class Application {
|
|
public:
|
|
static Application &GetInstance();
|
|
|
|
virtual ~Application();
|
|
|
|
/// Initializes the application, and in particular, finds the path for
|
|
/// the resources. If you can provide the argc/argv arguments it is more
|
|
/// reliable.
|
|
void Initialize();
|
|
/// Initializes the application, and in particular, finds the path for
|
|
/// the resources. If you can provide the argc/argv arguments it is more
|
|
/// reliable.
|
|
void Initialize(int argc, const char *argv[]);
|
|
/// Initializes the application, with a specific path to the resources.
|
|
void Initialize(const char *resource_path);
|
|
|
|
/// Identifier for font used by default for all UI elements
|
|
static constexpr FontId DEFAULT_FONT_ID = 0;
|
|
/// Adds a font. Must be called after Initialize() and before a window is
|
|
/// created.
|
|
FontId AddFont(const FontDescription &fd);
|
|
/// Replaces font. Must be called after Initialize() and before a window is
|
|
/// created.
|
|
void SetFont(FontId id, const FontDescription &fd);
|
|
|
|
/// Does not return until the UI is completely finished.
|
|
void Run();
|
|
/// Closes all the windows, which exits as a result
|
|
void Quit();
|
|
|
|
/// Runs \param f in a separate thread. Do NOT call UI functions in
|
|
/// \p f; if you have a long running function that needs to call UI
|
|
/// functions (e.g. updating a progress bar), have your function call
|
|
/// PostToMainThread() with code that will do the UI (note: your function
|
|
/// may finish before the code given to PostToMainThread will run, so if
|
|
/// using lambdas, capture by copy and make sure whatever you use will
|
|
/// still be alive).
|
|
void RunInThread(std::function<void()> f);
|
|
/// Runs \p f on the main thread at some point in the near future.
|
|
/// Proper context will be setup for \p window. \p f will block the
|
|
/// UI, so it should run quickly. If you need to do something slow
|
|
/// (e.g. load a file) consider using RunInThread() and have the function
|
|
/// pass off UI calls to PostToMainThread().
|
|
void PostToMainThread(Window *window, std::function<void()> f);
|
|
|
|
std::shared_ptr<Menu> GetMenubar() const;
|
|
void SetMenubar(std::shared_ptr<Menu> menubar);
|
|
|
|
/// Must be called on the same thread that calls Run()
|
|
void AddWindow(std::shared_ptr<Window> window);
|
|
/// Must be called on the same thread that calls Run(). This is normally
|
|
/// called from Window::Close() and should not need to be called in user
|
|
/// code.
|
|
void RemoveWindow(Window *window);
|
|
|
|
/// Creates a message box window the next time the event loop processes.
|
|
/// This message box will be a separate window and not associated with any
|
|
/// of the other windows shown with AddWindow().
|
|
/// THIS FUNCTION SHOULD BE USED ONLY AS A LAST RESORT!
|
|
/// If you have a window, you should use Window::ShowMessageBox() so that
|
|
/// the message box will be modal to that window. If you do not have a
|
|
/// window it is better to use ShowNativeAlert(). If the platform does not
|
|
/// have an alert (like Linux), then this can be used as a last resort.
|
|
void ShowMessageBox(const char *title, const char *message);
|
|
|
|
WindowSystem &GetWindowSystem() const;
|
|
|
|
// (std::string not good in interfaces for ABI reasons)
|
|
const char *GetResourcePath() const;
|
|
|
|
/// This is primarily intended for use by the Window class. Any size-related
|
|
/// fields (for example, fontSize) should be accessed through
|
|
/// Window::GetTheme() as they are updated to reflect the pixel scaling
|
|
/// on the monitor where the Window is displayed.
|
|
const Theme &GetTheme() const;
|
|
|
|
/// Returns high-resolution counter value (in seconds). Not valid
|
|
/// until Initialize() is called.
|
|
double Now() const;
|
|
|
|
/// Delivers the itemId to the active window. Used internally.
|
|
void OnMenuItemSelected(Menu::ItemId itemId);
|
|
|
|
/// Cleanup everything right now. An example of usage is Cocoa's
|
|
/// -applicationWillTermiate: AppDelegate message. Using Quit would result
|
|
/// in a crash (and an unsightly message from macOS) due to destructing
|
|
/// the windows at the wrong time.
|
|
void OnTerminate();
|
|
|
|
class EnvUnlocker {
|
|
public:
|
|
EnvUnlocker() {}
|
|
virtual ~EnvUnlocker() {}
|
|
virtual void unlock() {}
|
|
virtual void relock() {}
|
|
};
|
|
/// For internal use. Returns true if the run loop has not finished, and
|
|
/// false if the last window has closed or Quit() has been called.
|
|
/// EnvUnlocker allows an external environment to provide
|
|
/// a way to unlock the environment while we wait for the next event.
|
|
/// This is useful to release the Python GIL, for example. Callers of
|
|
/// of Open3D's GUI from languages such as scripting languages which do
|
|
/// not expect the author to need to clean up after themselves may want to
|
|
/// write their own Run() function that calls RunOneTick() with
|
|
/// cleanup_if_no_windows=false and schedule a call to OnTerminate() with
|
|
/// atexit().
|
|
bool RunOneTick(EnvUnlocker &unlocker, bool cleanup_if_no_windows = true);
|
|
|
|
/// Sets the WindowSystem to given object. Can be used to override the
|
|
/// default GLFWWindowSystem (e.g. BitmapWindowSystem). Must be called
|
|
/// before creating any Windows.
|
|
void SetWindowSystem(std::shared_ptr<WindowSystem> ws);
|
|
|
|
/// Returns true if using the native OS window system, false otherwise.
|
|
/// This is useful for choosing to display some features that are only
|
|
/// useful with native windows. For instance, when embedded in a Jupyter
|
|
/// notebook, a "Close Window" menu item is not necessary.
|
|
bool UsingNativeWindows() const;
|
|
|
|
/// Verifies that Initialize() has been called, printing out an error and
|
|
/// exiting if not.
|
|
void VerifyIsInitialized();
|
|
|
|
const std::vector<FontDescription> &GetFontDescriptions() const;
|
|
|
|
/// Returns the scene rendered to an image. This MUST NOT be called while
|
|
/// in Run(). It is intended for use when no windows are shown. If you
|
|
/// need to render from a GUI, use Scene::RenderToImage().
|
|
std::shared_ptr<geometry::Image> RenderToImage(
|
|
rendering::Renderer &renderer,
|
|
rendering::View *view,
|
|
rendering::Scene *scene,
|
|
int width,
|
|
int height);
|
|
|
|
// Same as RenderToImage(), but returns the depth values in a float image.
|
|
std::shared_ptr<geometry::Image> RenderToDepthImage(
|
|
rendering::Renderer &renderer,
|
|
rendering::View *view,
|
|
rendering::Scene *scene,
|
|
int width,
|
|
int height,
|
|
bool z_in_view_space = false);
|
|
|
|
private:
|
|
Application();
|
|
|
|
enum class RunStatus { CONTINUE, DONE };
|
|
RunStatus ProcessQueuedEvents(EnvUnlocker &unlocker);
|
|
|
|
private:
|
|
struct Impl;
|
|
std::unique_ptr<Impl> impl_;
|
|
};
|
|
|
|
} // namespace gui
|
|
} // namespace visualization
|
|
} // namespace open3d
|