-Remove harcoded opengl extension testing from OS, ask rasterizer instead.

-Fixed a bug where etc textures were imported broken

audio_driver_media_kit.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -32,7 +32,7 @@
 
 #ifdef MEDIA_KIT_ENABLED
 
-#include "project_settings.h"
+#include "core/project_settings.h"
 
 int32_t *AudioDriverMediaKit::samples_in = NULL;
 
@@ -43,7 +43,7 @@ Error AudioDriverMediaKit::init() {
 	speaker_mode = SPEAKER_MODE_STEREO;
 	channels = 2;
 
-	int latency = GLOBAL_DEF("audio/output_latency", 25);
+	int latency = GLOBAL_DEF_RST("audio/output_latency", 25);
 	buffer_size = next_power_of_2(latency * mix_rate / 1000);
 	samples_in = memnew_arr(int32_t, buffer_size * channels);
 
@@ -100,7 +100,7 @@ int AudioDriverMediaKit::get_mix_rate() const {
 	return mix_rate;
 }
 
-AudioDriverSW::SpeakerMode AudioDriverMediaKit::get_speaker_mode() const {
+AudioDriverMediaKit::SpeakerMode AudioDriverMediaKit::get_speaker_mode() const {
 	return speaker_mode;
 }
 

audio_driver_media_kit.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -35,9 +35,10 @@
 #include "core/os/mutex.h"
 #include "core/os/thread.h"
 
-#include <SoundPlayer.h>
 #include <kernel/image.h> // needed for image_id
 
+#include <SoundPlayer.h>
+
 class AudioDriverMediaKit : public AudioDriver {
 	Mutex *mutex;
 

context_gl_haiku.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */

context_gl_haiku.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -46,9 +46,6 @@ private:
 	bool use_vsync;
 
 public:
-	ContextGL_Haiku(HaikuDirectWindow *p_window);
-	~ContextGL_Haiku();
-
 	virtual Error initialize();
 	virtual void release_current();
 	virtual void make_current();
@@ -58,6 +55,9 @@ public:
 
 	virtual void set_use_vsync(bool p_use);
 	virtual bool is_using_vsync() const;
+
+	ContextGL_Haiku(HaikuDirectWindow *p_window);
+	virtual ~ContextGL_Haiku();
 };
 
 #endif

detect.py

@@ -22,7 +22,7 @@ def get_opts():
     from SCons.Variables import EnumVariable
 
     return [
-        EnumVariable('debug_symbols', 'Add debug symbols to release version', 'yes', ('yes', 'no', 'full')),
+        EnumVariable('debug_symbols', 'Add debugging symbols to release builds', 'yes', ('yes', 'no', 'full')),
     ]
 
 
@@ -37,14 +37,14 @@ def configure(env):
     ## Build type
 
     if (env["target"] == "release"):
-        env.Prepend(CCFLAGS=['-O3', '-ffast-math'])
+        env.Prepend(CCFLAGS=['-O3'])
         if (env["debug_symbols"] == "yes"):
             env.Prepend(CCFLAGS=['-g1'])
         if (env["debug_symbols"] == "full"):
             env.Prepend(CCFLAGS=['-g2'])
 
     elif (env["target"] == "release_debug"):
-        env.Prepend(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED'])
+        env.Prepend(CCFLAGS=['-O2', '-DDEBUG_ENABLED'])
         if (env["debug_symbols"] == "yes"):
             env.Prepend(CCFLAGS=['-g1'])
         if (env["debug_symbols"] == "full"):
@@ -64,10 +64,91 @@ def configure(env):
     env["CC"] = "gcc-x86"
     env["CXX"] = "g++-x86"
 
+    ## Dependencies
+
+    if not env['builtin_libwebp']:
+        env.ParseConfig('pkg-config libwebp --cflags --libs')
+
+    # freetype depends on libpng and zlib, so bundling one of them while keeping others
+    # as shared libraries leads to weird issues
+    if env['builtin_freetype'] or env['builtin_libpng'] or env['builtin_zlib']:
+        env['builtin_freetype'] = True
+        env['builtin_libpng'] = True
+        env['builtin_zlib'] = True
+
+    if not env['builtin_freetype']:
+        env.ParseConfig('pkg-config freetype2 --cflags --libs')
+
+    if not env['builtin_libpng']:
+        env.ParseConfig('pkg-config libpng --cflags --libs')
+
+    if not env['builtin_bullet']:
+        # We need at least version 2.88
+        import subprocess
+        bullet_version = subprocess.check_output(['pkg-config', 'bullet', '--modversion']).strip()
+        if bullet_version < "2.88":
+            # Abort as system bullet was requested but too old
+            print("Bullet: System version {0} does not match minimal requirements ({1}). Aborting.".format(bullet_version, "2.88"))
+            sys.exit(255)
+        env.ParseConfig('pkg-config bullet --cflags --libs')
+
+    if not env['builtin_enet']:
+        env.ParseConfig('pkg-config libenet --cflags --libs')
+
+    if not env['builtin_squish'] and env['tools']:
+        env.ParseConfig('pkg-config libsquish --cflags --libs')
+
+    if not env['builtin_zstd']:
+        env.ParseConfig('pkg-config libzstd --cflags --libs')
+
+    # Sound and video libraries
+    # Keep the order as it triggers chained dependencies (ogg needed by others, etc.)
+
+    if not env['builtin_libtheora']:
+        env['builtin_libogg'] = False  # Needed to link against system libtheora
+        env['builtin_libvorbis'] = False  # Needed to link against system libtheora
+        env.ParseConfig('pkg-config theora theoradec --cflags --libs')
+
+    if not env['builtin_libvpx']:
+        env.ParseConfig('pkg-config vpx --cflags --libs')
+
+    if not env['builtin_libvorbis']:
+        env['builtin_libogg'] = False  # Needed to link against system libvorbis
+        env.ParseConfig('pkg-config vorbis vorbisfile --cflags --libs')
+
+    if not env['builtin_opus']:
+        env['builtin_libogg'] = False  # Needed to link against system opus
+        env.ParseConfig('pkg-config opus opusfile --cflags --libs')
+
+    if not env['builtin_libogg']:
+        env.ParseConfig('pkg-config ogg --cflags --libs')
+
+    if env['builtin_libtheora']:
+        list_of_x86 = ['x86_64', 'x86', 'i386', 'i586']
+        if any(platform.machine() in s for s in list_of_x86):
+            env["x86_libtheora_opt_gcc"] = True
+
+    if not env['builtin_libwebsockets']:
+        env.ParseConfig('pkg-config libwebsockets --cflags --libs')
+
+    if not env['builtin_mbedtls']:
+        # mbedTLS does not provide a pkgconfig config yet. See https://github.com/ARMmbed/mbedtls/issues/228
+        env.Append(LIBS=['mbedtls', 'mbedcrypto', 'mbedx509'])
+
+    if not env['builtin_miniupnpc']:
+        # No pkgconfig file so far, hardcode default paths.
+        env.Append(CPPPATH=["/system/develop/headers/x86/miniupnpc"])
+        env.Append(LIBS=["miniupnpc"])
+
+    # On Linux wchar_t should be 32-bits
+    # 16-bit library shouldn't be required due to compiler optimisations
+    if not env['builtin_pcre2']:
+        env.ParseConfig('pkg-config libpcre2-32 --cflags --libs')
+
     ## Flags
 
     env.Append(CPPPATH=['#platform/haiku'])
-    env.Append(CPPFLAGS=['-DUNIX_ENABLED', '-DOPENGL_ENABLED', '-DGLES_ENABLED', '-DGLES_OVER_GL'])
+    env.Append(CPPFLAGS=['-DUNIX_ENABLED', '-DOPENGL_ENABLED', '-DGLES_ENABLED'])
     env.Append(CPPFLAGS=['-DMEDIA_KIT_ENABLED'])
     # env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
     env.Append(CPPFLAGS=['-DPTHREAD_NO_RENAME'])  # TODO: enable when we have pthread_setname_np

godot_haiku.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */

haiku_application.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */

haiku_application.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -31,9 +31,10 @@
 #ifndef HAIKU_APPLICATION_H
 #define HAIKU_APPLICATION_H
 
-#include <Application.h>
 #include <kernel/image.h> // needed for image_id
 
+#include <Application.h>
+
 class HaikuApplication : public BApplication {
 public:
 	HaikuApplication();

haiku_direct_window.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -30,10 +30,10 @@
 
 #include <UnicodeChar.h>
 
+#include "core/os/keyboard.h"
 #include "haiku_direct_window.h"
 #include "key_mapping_haiku.h"
 #include "main/main.h"
-#include "os/keyboard.h"
 
 HaikuDirectWindow::HaikuDirectWindow(BRect p_frame) :
 		BDirectWindow(p_frame, "Godot", B_TITLED_WINDOW, B_QUIT_ON_WINDOW_CLOSE) {
@@ -41,10 +41,14 @@ HaikuDirectWindow::HaikuDirectWindow(BRect p_frame) :
 	last_buttons_state = 0;
 	last_button_mask = 0;
 	last_key_modifier_state = 0;
+
+	view = NULL;
+	update_runner = NULL;
+	input = NULL;
+	main_loop = NULL;
 }
 
 HaikuDirectWindow::~HaikuDirectWindow() {
-	delete update_runner;
 }
 
 void HaikuDirectWindow::SetHaikuGLView(HaikuGLView *p_view) {
@@ -53,7 +57,7 @@ void HaikuDirectWindow::SetHaikuGLView(HaikuGLView *p_view) {
 
 void HaikuDirectWindow::StartMessageRunner() {
 	update_runner = new BMessageRunner(BMessenger(this),
-			new BMessage(REDRAW_MSG), 1000000 / 30 /* 30 fps */);
+			new BMessage(REDRAW_MSG), 1000000 / 60 /* 60 fps */);
 }
 
 void HaikuDirectWindow::StopMessageRunner() {
@@ -69,6 +73,7 @@ void HaikuDirectWindow::SetMainLoop(MainLoop *p_main_loop) {
 }
 
 bool HaikuDirectWindow::QuitRequested() {
+	StopMessageRunner();
 	main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
 	return false;
 }
@@ -81,7 +86,7 @@ void HaikuDirectWindow::DirectConnected(direct_buffer_info *info) {
 void HaikuDirectWindow::MessageReceived(BMessage *message) {
 	switch (message->what) {
 		case REDRAW_MSG:
-			if (Main::iteration() == true) {
+			if (Main::iteration()) {
 				view->EnableDirectMode(false);
 				Quit();
 			}
@@ -152,39 +157,36 @@ void HaikuDirectWindow::HandleMouseButton(BMessage *message) {
 	}
 	*/
 
-	Ref<InputEvent> mouse_event;
-	mouse_event.type = Ref<InputEvent>::MOUSE_BUTTON;
-	mouse_event.device = 0;
+	Ref<InputEventMouseButton> mouse_event;
+	mouse_event.instance();
 
-	mouse_event.mouse_button.mod = GetKeyModifierState(modifiers);
-	mouse_event->get_button_mask() = GetMouseButtonState(buttons);
-	mouse_event->get_position().x = where.x;
-	mouse_event->get_position().y = where.y;
-	mouse_event.mouse_button.global_x = where.x;
-	mouse_event.mouse_button.global_y = where.y;
+	mouse_event->set_button_mask(GetMouseButtonState(buttons));
+	mouse_event->set_position({ where.x, where.y });
+	mouse_event->set_global_position({ where.x, where.y });
+	GetKeyModifierState(mouse_event, modifiers);
 
 	switch (button) {
 		default:
 		case B_PRIMARY_MOUSE_BUTTON:
-			mouse_event->get_button_index() = 1;
+			mouse_event->set_button_index(1);
 			break;
 
 		case B_SECONDARY_MOUSE_BUTTON:
-			mouse_event->get_button_index() = 2;
+			mouse_event->set_button_index(2);
 			break;
 
 		case B_TERTIARY_MOUSE_BUTTON:
-			mouse_event->get_button_index() = 3;
+			mouse_event->set_button_index(3);
 			break;
 	}
 
-	mouse_event->is_pressed() = (message->what == B_MOUSE_DOWN);
+	mouse_event->set_pressed(message->what == B_MOUSE_DOWN);
 
 	if (message->what == B_MOUSE_DOWN && mouse_event->get_button_index() == 1) {
 		int32 clicks = message->FindInt32("clicks");
 
 		if (clicks > 1) {
-			mouse_event.mouse_button.doubleclick = true;
+			mouse_event->set_doubleclick(true);
 		}
 	}
 
@@ -208,22 +210,18 @@ void HaikuDirectWindow::HandleMouseMoved(BMessage *message) {
 
 	Point2i rel = pos - last_mouse_position;
 
-	Ref<InputEvent> motion_event;
-	motion_event.type = Ref<InputEvent>::MOUSE_MOTION;
-	motion_event.device = 0;
+	Ref<InputEventMouseMotion> motion_event;
+	motion_event.instance();
+	GetKeyModifierState(motion_event, modifiers);
 
-	motion_event.mouse_motion.mod = GetKeyModifierState(modifiers);
-	motion_event->get_button_mask() = GetMouseButtonState(buttons);
-	motion_event.mouse_motion.x = pos.x;
-	motion_event.mouse_motion.y = pos.y;
+	motion_event->set_button_mask(GetMouseButtonState(buttons));
+	motion_event->set_position({ pos.x, pos.y });
 	input->set_mouse_position(pos);
-	motion_event.mouse_motion.global_x = pos.x;
-	motion_event.mouse_motion.global_y = pos.y;
-	motion_event.mouse_motion.speed_x = input->get_last_mouse_speed().x;
-	motion_event.mouse_motion.speed_y = input->get_last_mouse_speed().y;
+	motion_event->set_global_position({ pos.x, pos.y });
+	motion_event->set_speed({ input->get_last_mouse_speed().x,
+			input->get_last_mouse_speed().y });
 
-	motion_event->get_relative().x = rel.x;
-	motion_event->get_relative().y = rel.y;
+	motion_event->set_relative({ rel.x, rel.y });
 
 	last_mouse_position = pos;
 
@@ -236,22 +234,21 @@ void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) {
 		return;
 	}
 
-	Ref<InputEvent> mouse_event;
-	mouse_event.type = Ref<InputEvent>::MOUSE_BUTTON;
-	mouse_event.device = 0;
+	Ref<InputEventMouseButton> mouse_event;
+	mouse_event.instance();
+	//GetKeyModifierState(mouse_event, modifiers);
 
-	mouse_event->get_button_index() = wheel_delta_y < 0 ? 4 : 5;
-	mouse_event.mouse_button.mod = GetKeyModifierState(last_key_modifier_state);
-	mouse_event->get_button_mask() = last_button_mask;
-	mouse_event->get_position().x = last_mouse_position.x;
-	mouse_event->get_position().y = last_mouse_position.y;
-	mouse_event.mouse_button.global_x = last_mouse_position.x;
-	mouse_event.mouse_button.global_y = last_mouse_position.y;
+	mouse_event->set_button_index(wheel_delta_y < 0 ? 4 : 5);
+	mouse_event->set_button_mask(last_button_mask);
+	mouse_event->set_position({ last_mouse_position.x,
+			last_mouse_position.y });
+	mouse_event->set_global_position({ last_mouse_position.x,
+			last_mouse_position.y });
 
-	mouse_event->is_pressed() = true;
+	mouse_event->set_pressed(true);
 	input->parse_input_event(mouse_event);
 
-	mouse_event->is_pressed() = false;
+	mouse_event->set_pressed(false);
 	input->parse_input_event(mouse_event);
 }
 
@@ -272,24 +269,23 @@ void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) {
 		return;
 	}
 
-	Ref<InputEvent> event;
-	event.type = Ref<InputEvent>::KEY;
-	event.device = 0;
-	event.key.mod = GetKeyModifierState(modifiers);
-	event->is_pressed() = (message->what == B_KEY_DOWN);
-	event->get_scancode() = KeyMappingHaiku::get_keysym(raw_char, key);
-	event->is_echo() = message->HasInt32("be:key_repeat");
-	event.key.unicode = 0;
+	Ref<InputEventKey> event;
+	event.instance();
+	GetKeyModifierState(event, modifiers);
+	event->set_pressed(message->what == B_KEY_DOWN);
+	event->set_scancode(KeyMappingHaiku::get_keysym(raw_char, key));
+	event->set_echo(message->HasInt32("be:key_repeat"));
+	event->set_unicode(0);
 
 	const char *bytes = NULL;
 	if (message->FindString("bytes", &bytes) == B_OK) {
-		event.key.unicode = BUnicodeChar::FromUTF8(&bytes);
+		event->set_unicode(BUnicodeChar::FromUTF8(&bytes));
 	}
 
 	//make it consistent across platforms.
 	if (event->get_scancode() == KEY_BACKTAB) {
-		event->get_scancode() = KEY_TAB;
-		event->get_shift() = true;
+		event->set_scancode(KEY_TAB);
+		event->set_shift(true);
 	}
 
 	input->parse_input_event(event);
@@ -309,14 +305,14 @@ void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage *message) {
 
 	int32 key = old_modifiers ^ modifiers;
 
-	Ref<InputEvent> event;
-	event.type = Ref<InputEvent>::KEY;
-	event.device = 0;
-	event.key.mod = GetKeyModifierState(modifiers);
-	event->is_pressed() = ((modifiers & key) != 0);
-	event->get_scancode() = KeyMappingHaiku::get_modifier_keysym(key);
-	event->is_echo() = false;
-	event.key.unicode = 0;
+	Ref<InputEventWithModifiers> event;
+	event.instance();
+	GetKeyModifierState(event, modifiers);
+
+	event->set_shift(key & B_SHIFT_KEY);
+	event->set_alt(key & B_OPTION_KEY);
+	event->set_control(key & B_CONTROL_KEY);
+	event->set_command(key & B_COMMAND_KEY);
 
 	input->parse_input_event(event);
 }
@@ -333,14 +329,13 @@ void HaikuDirectWindow::HandleWindowResized(BMessage *message) {
 	current_video_mode->height = height;
 }
 
-inline InputModifierState HaikuDirectWindow::GetKeyModifierState(uint32 p_state) {
+inline void HaikuDirectWindow::GetKeyModifierState(Ref<InputEventWithModifiers> event, uint32 p_state) {
 	last_key_modifier_state = p_state;
-	InputModifierState state;
 
-	state.shift = (p_state & B_SHIFT_KEY) != 0;
-	state.control = (p_state & B_CONTROL_KEY) != 0;
-	state.alt = (p_state & B_OPTION_KEY) != 0;
-	state.meta = (p_state & B_COMMAND_KEY) != 0;
+	event->set_shift(p_state & B_SHIFT_KEY);
+	event->set_control(p_state & B_CONTROL_KEY);
+	event->set_alt(p_state & B_OPTION_KEY);
+	event->set_metakey(p_state & B_COMMAND_KEY);
 
 	return state;
 }

haiku_direct_window.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -31,9 +31,10 @@
 #ifndef HAIKU_DIRECT_WINDOW_H
 #define HAIKU_DIRECT_WINDOW_H
 
-#include <DirectWindow.h>
 #include <kernel/image.h> // needed for image_id
 
+#include <DirectWindow.h>
+
 #include "core/os/os.h"
 #include "main/input_default.h"
 
@@ -63,7 +64,7 @@ private:
 	void HandleWindowResized(BMessage *message);
 	void HandleKeyboardEvent(BMessage *message);
 	void HandleKeyboardModifierEvent(BMessage *message);
-	inline InputModifierState GetKeyModifierState(uint32 p_state);
+	inline void GetKeyModifierState(Ref<InputEventWithModifiers> event, uint32 p_state);
 	inline int GetMouseButtonState(uint32 p_state);
 
 public:

haiku_gl_view.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */

haiku_gl_view.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -31,9 +31,10 @@
 #ifndef HAIKU_GL_VIEW_H
 #define HAIKU_GL_VIEW_H
 
-#include <GLView.h>
 #include <kernel/image.h> // needed for image_id
 
+#include <GLView.h>
+
 class HaikuGLView : public BGLView {
 public:
 	HaikuGLView(BRect frame, uint32 type);

key_mapping_haiku.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -30,8 +30,8 @@
 
 #include <InterfaceDefs.h>
 
+#include "core/os/keyboard.h"
 #include "key_mapping_haiku.h"
-#include "os/keyboard.h"
 
 struct _HaikuTranslatePair {
 	unsigned int keysym;

key_mapping_haiku.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */

os_haiku.cpp

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -28,9 +28,10 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
+#include "drivers/gles3/rasterizer_gles3.h"
+
 #include "os_haiku.h"
 
-#include "drivers/gles3/rasterizer_gles3.h"
 #include "main/main.h"
 #include "servers/physics/physics_server_sw.h"
 #include "servers/visual/visual_server_raster.h"
@@ -80,6 +81,10 @@ const char *OS_Haiku::get_video_driver_name(int p_driver) const {
 	return "GLES3";
 }
 
+int OS_Haiku::get_current_video_driver() const {
+	return video_driver_index;
+}
+
 Error OS_Haiku::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
 	main_loop = NULL;
 	current_video_mode = p_desired;
@@ -107,22 +112,20 @@ Error OS_Haiku::initialize(const VideoMode &p_desired, int p_video_driver, int p
 	context_gl->initialize();
 	context_gl->make_current();
 	context_gl->set_use_vsync(current_video_mode.use_vsync);
-
-	/* Port to GLES 3 rasterizer */
-	//rasterizer = memnew(RasterizerGLES2);
+	RasterizerGLES3::register_config();
+	RasterizerGLES3::make_current();
 
 #endif
 
-	visual_server = memnew(VisualServerRaster(rasterizer));
+	visual_server = memnew(VisualServerRaster);
+	// FIXME: Reimplement threaded rendering
+	if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
+		visual_server = memnew(VisualServerWrapMT(visual_server, false));
+	}
 
 	ERR_FAIL_COND_V(!visual_server, ERR_UNAVAILABLE);
 
-	// TODO: enable multithreaded VS
-	/*
-	if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
-		visual_server = memnew(VisualServerWrapMT(visual_server, get_render_thread_mode() == RENDER_SEPARATE_THREAD));
-	}
-	*/
+	video_driver_index = p_video_driver;
 
 	input = memnew(InputDefault);
 	window->SetInput(input);
@@ -132,8 +135,6 @@ Error OS_Haiku::initialize(const VideoMode &p_desired, int p_video_driver, int p
 
 	AudioDriverManager::initialize(p_audio_driver);
 
-	power_manager = memnew(PowerHaiku);
-
 	return OK;
 }
 
@@ -146,7 +147,6 @@ void OS_Haiku::finalize() {
 
 	visual_server->finish();
 	memdelete(visual_server);
-	memdelete(rasterizer);
 
 	memdelete(input);
 
@@ -322,7 +322,7 @@ String OS_Haiku::get_executable_path() const {
 
 bool OS_Haiku::_check_internal_feature_support(const String &p_feature) {
 
-	return p_feature == "pc" || p_feature == "s3tc";
+	return p_feature == "pc";
 }
 
 String OS_Haiku::get_config_path() const {
@@ -330,7 +330,7 @@ String OS_Haiku::get_config_path() const {
 	if (has_environment("XDG_CONFIG_HOME")) {
 		return get_environment("XDG_CONFIG_HOME");
 	} else if (has_environment("HOME")) {
-		return get_environment("HOME").plus_file(".config");
+		return get_environment("HOME").plus_file("config/settings");
 	} else {
 		return ".";
 	}
@@ -341,7 +341,7 @@ String OS_Haiku::get_data_path() const {
 	if (has_environment("XDG_DATA_HOME")) {
 		return get_environment("XDG_DATA_HOME");
 	} else if (has_environment("HOME")) {
-		return get_environment("HOME").plus_file(".local/share");
+		return get_environment("HOME").plus_file("config/data");
 	} else {
 		return get_config_path();
 	}
@@ -352,8 +352,23 @@ String OS_Haiku::get_cache_path() const {
 	if (has_environment("XDG_CACHE_HOME")) {
 		return get_environment("XDG_CACHE_HOME");
 	} else if (has_environment("HOME")) {
-		return get_environment("HOME").plus_file(".cache");
+		return get_environment("HOME").plus_file("config/cache");
 	} else {
 		return get_config_path();
 	}
 }
+
+OS::PowerState OS_Haiku::get_power_state() {
+	WARN_PRINT("Power management is not implemented on this platform, defaulting to POWERSTATE_UNKNOWN");
+	return OS::POWERSTATE_UNKNOWN;
+}
+
+int OS_Haiku::get_power_seconds_left() {
+	WARN_PRINT("Power management is not implemented on this platform, defaulting to -1");
+	return -1;
+}
+
+int OS_Haiku::get_power_percent_left() {
+	WARN_PRINT("Power management is not implemented on this platform, defaulting to -1");
+	return -1;
+}

os_haiku.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -37,9 +37,7 @@
 #include "haiku_application.h"
 #include "haiku_direct_window.h"
 #include "main/input_default.h"
-#include "power_haiku.h"
 #include "servers/audio_server.h"
-#include "servers/visual/rasterizer.h"
 #include "servers/visual_server.h"
 
 class OS_Haiku : public OS_Unix {
@@ -48,10 +46,9 @@ private:
 	HaikuDirectWindow *window;
 	MainLoop *main_loop;
 	InputDefault *input;
-	Rasterizer *rasterizer;
 	VisualServer *visual_server;
 	VideoMode current_video_mode;
-	PowerHaiku *power_manager;
+	int video_driver_index;
 
 #ifdef MEDIA_KIT_ENABLED
 	AudioDriverMediaKit driver_media_kit;
@@ -66,6 +63,7 @@ private:
 protected:
 	virtual int get_video_driver_count() const;
 	virtual const char *get_video_driver_name(int p_driver) const;
+	virtual int get_current_video_driver() const;
 
 	virtual Error initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver);
 	virtual void finalize();

platform_config.h

@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -33,4 +33,5 @@
 // for ifaddrs.h needed in drivers/unix/ip_unix.cpp
 #define _BSD_SOURCE 1
 
-#define GLES3_INCLUDE_H "glad/glad.h"
+#define GLES3_INCLUDE_H "thirdparty/glad/glad/glad.h"
+#define GLES2_INCLUDE_H "thirdparty/glad/glad/glad.h"

power_haiku.cpp

@@ -1,74 +0,0 @@
-/*************************************************************************/
-/*  power_haiku.cpp                                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* 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.                */
-/*************************************************************************/
-
-#include "core/error_macros.h"
-
-#include "power_haiku.h"
-
-bool PowerHaiku::UpdatePowerInfo() {
-
-	return false;
-}
-
-OS::PowerState PowerHaiku::get_power_state() {
-	if (UpdatePowerInfo()) {
-		return power_state;
-	} else {
-		WARN_PRINT("Power management is not implemented on this platform, defaulting to POWERSTATE_UNKNOWN");
-		return OS::POWERSTATE_UNKNOWN;
-	}
-}
-
-int PowerX11::get_power_seconds_left() {
-	if (UpdatePowerInfo()) {
-		return nsecs_left;
-	} else {
-		WARN_PRINT("Power management is not implemented on this platform, defaulting to -1");
-		return -1;
-	}
-}
-
-int PowerX11::get_power_percent_left() {
-	if (UpdatePowerInfo()) {
-		return percent_left;
-	} else {
-		WARN_PRINT("Power management is not implemented on this platform, defaulting to -1");
-		return -1;
-	}
-}
-
-PowerHaiku::PowerHaiku() :
-		nsecs_left(-1),
-		percent_left(-1),
-		power_state(OS::POWERSTATE_UNKNOWN) {
-}
-
-PowerHaiku::~PowerHaiku() {
-}

power_haiku.h

@@ -1,53 +0,0 @@
-/*************************************************************************/
-/*  power_haiku.h                                                        */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* 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.                */
-/*************************************************************************/
-
-#ifndef PLATFORM_HAIKU_POWER_HAIKU_H_
-#define PLATFORM_HAIKU_POWER_HAIKU_H_
-
-#include <os/os.h>
-
-class PowerHaiku {
-private:
-	int nsecs_left;
-	int percent_left;
-	OS::PowerState power_state;
-
-	bool UpdatePowerInfo();
-
-public:
-	PowerHaiku();
-	virtual ~PowerHaiku();
-
-	OS::PowerState get_power_state();
-	int get_power_seconds_left();
-	int get_power_percent_left();
-};
-
-#endif /* PLATFORM_HAIKU_POWER_HAIKU_H_ */