2016-06-18 14:46:12 +02:00
|
|
|
/*************************************************************************/
|
|
|
|
/* os_haiku.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:11:45 +02:00
|
|
|
/* https://godotengine.org */
|
2016-06-18 14:46:12 +02:00
|
|
|
/*************************************************************************/
|
2018-01-02 11:27:24 +01:00
|
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
|
2016-06-18 14:46:12 +02:00
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/*************************************************************************/
|
2015-06-21 01:08:31 +02:00
|
|
|
#include <Screen.h>
|
|
|
|
|
2015-05-28 02:42:40 +02:00
|
|
|
#include "drivers/gles2/rasterizer_gles2.h"
|
2015-06-11 21:57:41 +02:00
|
|
|
#include "servers/physics/physics_server_sw.h"
|
2017-03-19 00:36:26 +01:00
|
|
|
#include "servers/visual/visual_server_raster.h"
|
|
|
|
#include "servers/visual/visual_server_wrap_mt.h"
|
2015-06-20 02:43:11 +02:00
|
|
|
//#include "servers/physics_2d/physics_2d_server_wrap_mt.h"
|
2015-06-11 21:57:41 +02:00
|
|
|
#include "main/main.h"
|
|
|
|
|
2015-05-25 02:49:24 +02:00
|
|
|
#include "os_haiku.h"
|
|
|
|
|
2015-05-25 05:02:55 +02:00
|
|
|
OS_Haiku::OS_Haiku() {
|
2015-07-26 01:18:32 +02:00
|
|
|
#ifdef MEDIA_KIT_ENABLED
|
|
|
|
AudioDriverManagerSW::add_driver(&driver_media_kit);
|
|
|
|
#endif
|
2015-05-25 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
void OS_Haiku::run() {
|
2015-06-11 21:57:41 +02:00
|
|
|
if (!main_loop) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
main_loop->init();
|
2015-07-02 17:41:32 +02:00
|
|
|
context_gl->release_current();
|
|
|
|
|
|
|
|
// TODO: clean up
|
2017-03-19 00:36:26 +01:00
|
|
|
BMessenger *bms = new BMessenger(window);
|
|
|
|
BMessage *msg = new BMessage();
|
2015-07-02 17:41:32 +02:00
|
|
|
bms->SendMessage(LOCKGL_MSG, msg);
|
|
|
|
|
2015-06-16 20:52:24 +02:00
|
|
|
window->StartMessageRunner();
|
2015-06-11 21:57:41 +02:00
|
|
|
app->Run();
|
2015-06-16 20:52:24 +02:00
|
|
|
window->StopMessageRunner();
|
2015-06-11 21:57:41 +02:00
|
|
|
|
2015-06-20 02:43:11 +02:00
|
|
|
delete app;
|
2015-07-02 17:41:32 +02:00
|
|
|
|
|
|
|
delete bms;
|
|
|
|
delete msg;
|
2015-06-11 21:57:41 +02:00
|
|
|
main_loop->finish();
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2015-05-25 02:49:24 +02:00
|
|
|
String OS_Haiku::get_name() {
|
|
|
|
return "Haiku";
|
|
|
|
}
|
2015-05-25 05:02:55 +02:00
|
|
|
|
|
|
|
int OS_Haiku::get_video_driver_count() const {
|
2015-05-29 23:57:07 +02:00
|
|
|
return 1;
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
const char *OS_Haiku::get_video_driver_name(int p_driver) const {
|
2015-05-29 23:57:07 +02:00
|
|
|
return "GLES2";
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
OS::VideoMode OS_Haiku::get_default_video_mode() const {
|
2015-05-29 23:57:07 +02:00
|
|
|
return OS::VideoMode(800, 600, false);
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void OS_Haiku::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
|
2015-05-28 02:42:40 +02:00
|
|
|
main_loop = NULL;
|
2015-05-29 23:57:07 +02:00
|
|
|
current_video_mode = p_desired;
|
2015-05-28 02:42:40 +02:00
|
|
|
|
2015-06-11 21:57:41 +02:00
|
|
|
app = new HaikuApplication();
|
|
|
|
|
2015-06-16 20:52:24 +02:00
|
|
|
BRect frame;
|
|
|
|
frame.Set(50, 50, 50 + current_video_mode.width - 1, 50 + current_video_mode.height - 1);
|
|
|
|
|
|
|
|
window = new HaikuDirectWindow(frame);
|
2015-07-02 17:41:32 +02:00
|
|
|
window->SetVideoMode(¤t_video_mode);
|
2015-06-16 20:52:24 +02:00
|
|
|
|
2015-06-23 20:22:12 +02:00
|
|
|
if (current_video_mode.fullscreen) {
|
|
|
|
window->SetFullScreen(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!current_video_mode.resizable) {
|
|
|
|
uint32 flags = window->Flags();
|
|
|
|
flags |= B_NOT_RESIZABLE;
|
|
|
|
window->SetFlags(flags);
|
|
|
|
}
|
|
|
|
|
2015-05-28 02:42:40 +02:00
|
|
|
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
|
2015-06-16 20:52:24 +02:00
|
|
|
context_gl = memnew(ContextGL_Haiku(window));
|
2015-06-11 21:57:41 +02:00
|
|
|
context_gl->initialize();
|
2015-07-02 17:41:32 +02:00
|
|
|
context_gl->make_current();
|
2015-05-28 02:42:40 +02:00
|
|
|
|
|
|
|
rasterizer = memnew(RasterizerGLES2);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
visual_server = memnew(VisualServerRaster(rasterizer));
|
|
|
|
|
2015-06-11 21:57:41 +02:00
|
|
|
ERR_FAIL_COND(!visual_server);
|
|
|
|
|
2015-06-20 02:43:11 +02:00
|
|
|
// TODO: enable multithreaded VS
|
2015-06-16 20:52:24 +02:00
|
|
|
//if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
|
|
|
|
// visual_server = memnew(VisualServerWrapMT(visual_server, get_render_thread_mode() == RENDER_SEPARATE_THREAD));
|
|
|
|
//}
|
2015-05-29 23:57:07 +02:00
|
|
|
|
2015-07-02 17:41:32 +02:00
|
|
|
input = memnew(InputDefault);
|
|
|
|
window->SetInput(input);
|
|
|
|
|
|
|
|
window->Show();
|
2015-05-29 23:57:07 +02:00
|
|
|
visual_server->init();
|
2015-06-11 21:57:41 +02:00
|
|
|
|
|
|
|
physics_server = memnew(PhysicsServerSW);
|
|
|
|
physics_server->init();
|
|
|
|
physics_2d_server = memnew(Physics2DServerSW);
|
2015-06-20 02:43:11 +02:00
|
|
|
// TODO: enable multithreaded PS
|
|
|
|
//physics_2d_server = Physics2DServerWrapMT::init_server<Physics2DServerSW>();
|
2015-06-11 21:57:41 +02:00
|
|
|
physics_2d_server->init();
|
|
|
|
|
|
|
|
AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
|
|
|
|
|
|
|
|
if (AudioDriverManagerSW::get_driver(p_audio_driver)->init() != OK) {
|
|
|
|
ERR_PRINT("Initializing audio failed.");
|
|
|
|
}
|
|
|
|
|
|
|
|
sample_manager = memnew(SampleManagerMallocSW);
|
|
|
|
audio_server = memnew(AudioServerSW(sample_manager));
|
|
|
|
audio_server->init();
|
|
|
|
|
|
|
|
spatial_sound_server = memnew(SpatialSoundServerSW);
|
|
|
|
spatial_sound_server->init();
|
|
|
|
spatial_sound_2d_server = memnew(SpatialSound2DServerSW);
|
|
|
|
spatial_sound_2d_server->init();
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::finalize() {
|
2015-05-28 02:42:40 +02:00
|
|
|
if (main_loop) {
|
|
|
|
memdelete(main_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
main_loop = NULL;
|
|
|
|
|
2015-06-11 21:57:41 +02:00
|
|
|
spatial_sound_server->finish();
|
|
|
|
memdelete(spatial_sound_server);
|
|
|
|
|
|
|
|
spatial_sound_2d_server->finish();
|
|
|
|
memdelete(spatial_sound_2d_server);
|
|
|
|
|
2015-10-31 09:59:29 +01:00
|
|
|
memdelete(sample_manager);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2015-06-11 21:57:41 +02:00
|
|
|
audio_server->finish();
|
|
|
|
memdelete(audio_server);
|
|
|
|
|
2015-05-28 02:42:40 +02:00
|
|
|
visual_server->finish();
|
|
|
|
memdelete(visual_server);
|
|
|
|
memdelete(rasterizer);
|
2015-06-11 21:57:41 +02:00
|
|
|
|
|
|
|
physics_server->finish();
|
|
|
|
memdelete(physics_server);
|
|
|
|
|
|
|
|
physics_2d_server->finish();
|
|
|
|
memdelete(physics_2d_server);
|
|
|
|
|
2015-06-16 20:52:24 +02:00
|
|
|
memdelete(input);
|
|
|
|
|
2015-06-11 21:57:41 +02:00
|
|
|
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
|
|
|
|
memdelete(context_gl);
|
|
|
|
#endif
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void OS_Haiku::set_main_loop(MainLoop *p_main_loop) {
|
2015-05-28 02:42:40 +02:00
|
|
|
main_loop = p_main_loop;
|
2015-06-16 20:52:24 +02:00
|
|
|
input->set_main_loop(p_main_loop);
|
2015-06-20 00:59:32 +02:00
|
|
|
window->SetMainLoop(p_main_loop);
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
MainLoop *OS_Haiku::get_main_loop() const {
|
2015-05-28 02:42:40 +02:00
|
|
|
return main_loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::delete_main_loop() {
|
|
|
|
if (main_loop) {
|
|
|
|
memdelete(main_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
main_loop = NULL;
|
2015-06-20 00:59:32 +02:00
|
|
|
window->SetMainLoop(NULL);
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2015-06-11 21:57:41 +02:00
|
|
|
void OS_Haiku::release_rendering_thread() {
|
2015-06-16 20:52:24 +02:00
|
|
|
context_gl->release_current();
|
2015-06-11 21:57:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::make_rendering_thread() {
|
2015-06-16 20:52:24 +02:00
|
|
|
context_gl->make_current();
|
2015-06-11 21:57:41 +02:00
|
|
|
}
|
|
|
|
|
2015-05-25 05:02:55 +02:00
|
|
|
bool OS_Haiku::can_draw() const {
|
2015-06-11 21:57:41 +02:00
|
|
|
// TODO: implement
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::swap_buffers() {
|
|
|
|
context_gl->swap_buffers();
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Point2 OS_Haiku::get_mouse_pos() const {
|
2015-06-18 21:41:33 +02:00
|
|
|
return window->GetLastMousePosition();
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int OS_Haiku::get_mouse_button_state() const {
|
2015-06-18 21:41:33 +02:00
|
|
|
return window->GetLastButtonMask();
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::set_cursor_shape(CursorShape p_shape) {
|
2015-06-18 21:41:33 +02:00
|
|
|
//ERR_PRINT("set_cursor_shape() NOT IMPLEMENTED");
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
Hardware cursor implementation for Godot Engine 2.1
- Remove all references to the variable 'custom_mouse_cursor_hotspot' and 'custom_mouse_cursor' from the project settings.
- Indeed, to implement a custom cursor we need to define a sprite for each 'state' of the cursor. Using those variables in the projects settings would define only the _main_ cursor.
- Cleanup the VirtualServer (Remove references to cursor_set_visible, cursor_set_texture and cursor_set_pos)
- Cleanup the Input (set_mouse_in_window should not be used anymore)
- Update the documentation
- Implement it for windows, X11, Javascript, BB 10, OSx, iOS, server, android
- NOT IMPLEMENTED FOR WINRT (As of today, I'm not able to implement this one, this post might help)
- NOT IMPLEMENTED FOR HAIKU (Support of this platform seems perfunctory)
- Build it for Windows, Android and OSX
2017-12-01 06:32:43 +01:00
|
|
|
void OS_Haiku::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
|
|
|
// TODO: implement set_custom_mouse_cursor()
|
|
|
|
}
|
|
|
|
|
2015-06-21 01:08:31 +02:00
|
|
|
int OS_Haiku::get_screen_count() const {
|
|
|
|
// TODO: implement get_screen_count()
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int OS_Haiku::get_current_screen() const {
|
|
|
|
// TODO: implement get_current_screen()
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::set_current_screen(int p_screen) {
|
|
|
|
// TODO: implement set_current_screen()
|
|
|
|
}
|
|
|
|
|
|
|
|
Point2 OS_Haiku::get_screen_position(int p_screen) const {
|
|
|
|
// TODO: make this work with the p_screen parameter
|
2017-03-19 00:36:26 +01:00
|
|
|
BScreen *screen = new BScreen(window);
|
2015-06-21 01:08:31 +02:00
|
|
|
BRect frame = screen->Frame();
|
|
|
|
delete screen;
|
|
|
|
return Point2i(frame.left, frame.top);
|
|
|
|
}
|
|
|
|
|
|
|
|
Size2 OS_Haiku::get_screen_size(int p_screen) const {
|
|
|
|
// TODO: make this work with the p_screen parameter
|
2017-03-19 00:36:26 +01:00
|
|
|
BScreen *screen = new BScreen(window);
|
2015-06-21 01:08:31 +02:00
|
|
|
BRect frame = screen->Frame();
|
|
|
|
delete screen;
|
|
|
|
return Size2i(frame.IntegerWidth() + 1, frame.IntegerHeight() + 1);
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void OS_Haiku::set_window_title(const String &p_title) {
|
2015-06-11 21:57:41 +02:00
|
|
|
window->SetTitle(p_title.utf8().get_data());
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Size2 OS_Haiku::get_window_size() const {
|
2015-06-20 14:35:54 +02:00
|
|
|
BSize size = window->Size();
|
2015-06-21 01:08:31 +02:00
|
|
|
return Size2i(size.IntegerWidth() + 1, size.IntegerHeight() + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::set_window_size(const Size2 p_size) {
|
|
|
|
// TODO: why does it stop redrawing after this is called?
|
|
|
|
window->ResizeTo(p_size.x, p_size.y);
|
2015-06-20 14:35:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Point2 OS_Haiku::get_window_position() const {
|
|
|
|
BPoint point(0, 0);
|
|
|
|
window->ConvertToScreen(&point);
|
|
|
|
return Point2i(point.x, point.y);
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void OS_Haiku::set_window_position(const Point2 &p_position) {
|
2015-06-20 14:35:54 +02:00
|
|
|
window->MoveTo(p_position.x, p_position.y);
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
2015-06-21 01:08:31 +02:00
|
|
|
void OS_Haiku::set_window_fullscreen(bool p_enabled) {
|
|
|
|
window->SetFullScreen(p_enabled);
|
|
|
|
current_video_mode.fullscreen = p_enabled;
|
|
|
|
visual_server->init();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool OS_Haiku::is_window_fullscreen() const {
|
|
|
|
return current_video_mode.fullscreen;
|
|
|
|
}
|
|
|
|
|
2015-06-23 20:22:12 +02:00
|
|
|
void OS_Haiku::set_window_resizable(bool p_enabled) {
|
|
|
|
uint32 flags = window->Flags();
|
|
|
|
|
|
|
|
if (p_enabled) {
|
|
|
|
flags &= ~(B_NOT_RESIZABLE);
|
|
|
|
} else {
|
|
|
|
flags |= B_NOT_RESIZABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
window->SetFlags(flags);
|
2015-07-02 17:41:32 +02:00
|
|
|
current_video_mode.resizable = p_enabled;
|
2015-06-23 20:22:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool OS_Haiku::is_window_resizable() const {
|
2015-07-02 17:41:32 +02:00
|
|
|
return current_video_mode.resizable;
|
2015-06-23 20:22:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::set_window_minimized(bool p_enabled) {
|
|
|
|
window->Minimize(p_enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool OS_Haiku::is_window_minimized() const {
|
|
|
|
return window->IsMinimized();
|
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::set_window_maximized(bool p_enabled) {
|
|
|
|
window->Minimize(!p_enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool OS_Haiku::is_window_maximized() const {
|
|
|
|
return !window->IsMinimized();
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void OS_Haiku::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
|
2015-05-29 23:57:07 +02:00
|
|
|
ERR_PRINT("set_video_mode() NOT IMPLEMENTED");
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
OS::VideoMode OS_Haiku::get_video_mode(int p_screen) const {
|
2015-05-29 23:57:07 +02:00
|
|
|
return current_video_mode;
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void OS_Haiku::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
|
2015-05-29 23:57:07 +02:00
|
|
|
ERR_PRINT("get_fullscreen_mode_list() NOT IMPLEMENTED");
|
2015-05-25 05:02:55 +02:00
|
|
|
}
|
2015-05-25 05:34:16 +02:00
|
|
|
|
|
|
|
String OS_Haiku::get_executable_path() const {
|
|
|
|
return OS::get_executable_path();
|
|
|
|
}
|