Make event handling return a bool

example/test_app/src/cat.h

@@ -13,8 +13,8 @@ class Cat : public Node {
 		, atlas{atlas} {}
 	void
 	onDraw(Batch& batch, float parent_alpha, glm::mat4x4 transform) override;
-	void onMouseEvent(InputMouseEvent& event) override;
-	void onTouchEvent(InputTouchEvent& event) override;
+	bool onMouseEvent(const InputMouseEvent& event) override;
+	bool onTouchEvent(const InputTouchEvent& event) override;
 
 private:
 	TextureAtlas* atlas;

example/test_app/src/input.cpp

@@ -7,80 +7,83 @@
 
 using Growl::InputHandler;
 
-void InputHandler::onEvent(InputEvent& event) {
-	InputProcessor::onEvent(event);
-	root->onEvent(event);
+bool InputHandler::onEvent(const InputEvent& event) {
+	if (InputProcessor::onEvent(event)) {
+		return true;
+	}
+	return root->onEvent(event);
 }
 
-void InputHandler::onKeyboardEvent(InputKeyboardEvent& event) {
+bool InputHandler::onKeyboardEvent(const InputKeyboardEvent& event) {
 	switch (event.type) {
 	case KeyEventType::Unknown:
 		system.log(LogLevel::Warn, "InputHandler", "Got unknown key event!");
-		break;
+		return false;
 	case KeyEventType::KeyDown:
 	case KeyEventType::KeyUp:
 		switch (event.key) {
 		case Key::ArrowUp:
 		case Key::LetterW:
 			up = event.type == KeyEventType::KeyDown;
-			break;
+			return true;
 		case Key::ArrowDown:
 		case Key::LetterS:
 			down = event.type == KeyEventType::KeyDown;
-			break;
+			return true;
 		case Key::ArrowLeft:
 		case Key::LetterA:
 			left = event.type == KeyEventType::KeyDown;
-			break;
+			return true;
 		case Key::ArrowRight:
 		case Key::LetterD:
 			right = event.type == KeyEventType::KeyDown;
-			break;
+			return true;
 		case Key::LetterQ:
 			anticlockwise = event.type == KeyEventType::KeyDown;
-			break;
+			return true;
 		case Key::LetterE:
 			clockwise = event.type == KeyEventType::KeyDown;
-			break;
+			return true;
 		default:
-			break;
+			return false;
 		}
-		break;
+		return false;
 	}
 }
 
-void InputHandler::onControllerEvent(InputControllerEvent& event) {
+bool InputHandler::onControllerEvent(const InputControllerEvent& event) {
 	switch (event.type) {
 	case ControllerEventType::Unknown:
 		system.log(
 			LogLevel::Warn, "InputHandler", "Got unknown controller event!");
-		break;
+		return false;
 	case ControllerEventType::ButtonDown:
 	case ControllerEventType::ButtonUp:
 		switch (event.button) {
 		case ControllerButton::DpadUp:
 			up = event.type == ControllerEventType::ButtonDown;
-			break;
+			return true;
 		case ControllerButton::DpadDown:
 			down = event.type == ControllerEventType::ButtonDown;
-			break;
+			return true;
 		case ControllerButton::DpadLeft:
 			left = event.type == ControllerEventType::ButtonDown;
-			break;
+			return true;
 		case ControllerButton::DpadRight:
 			right = event.type == ControllerEventType::ButtonDown;
-			break;
+			return true;
 		case ControllerButton::LB:
 			anticlockwise = event.type == ControllerEventType::ButtonDown;
-			break;
+			return true;
 		case ControllerButton::RB:
 			clockwise = event.type == ControllerEventType::ButtonDown;
-			break;
+			return true;
 		default:
-			break;
+			return false;
 		}
-		break;
+		return false;
 	default:
-		break;
+		return false;
 	}
+	return false;
 }

example/test_app/src/input.h

@@ -13,11 +13,11 @@ class InputHandler : public InputProcessor {
 		: system{system}
 		, root{root} {}
 
-	void onEvent(InputEvent& event) override;
+	bool onEvent(const InputEvent& event) override;
 
-	void onKeyboardEvent(InputKeyboardEvent& event) override;
+	bool onKeyboardEvent(const InputKeyboardEvent& event) override;
 
-	void onControllerEvent(InputControllerEvent& event) override;
+	bool onControllerEvent(const InputControllerEvent& event) override;
 
 	bool upPressed() {
 		return up;

example/test_app/src/test_app_game.cpp

@@ -228,10 +228,12 @@ void Growl::Cat::onDraw(
 	batch.draw(region, 0, 0, getWidth(), getHeight(), transform);
 }
 
-void Growl::Cat::onMouseEvent(InputMouseEvent& event) {
+bool Growl::Cat::onMouseEvent(const InputMouseEvent& event) {
 	is_hit = hit(event.mouseX, event.mouseY);
+	return is_hit;
 }
 
-void Growl::Cat::onTouchEvent(InputTouchEvent& event) {
+bool Growl::Cat::onTouchEvent(const InputTouchEvent& event) {
 	is_hit = hit(event.touchX, event.touchY);
+	return is_hit;
 }

src/core/include/growl/core/api/scripting_api.h

@@ -54,14 +54,15 @@ class ClassSelf;
 class Script;
 
 using ScriptingParam = std::variant<
-	std::monostate, float, int, std::string_view, const void*,
+	std::monostate, bool, float, int, std::string_view, const void*,
 	std::unique_ptr<Object>, Object*>;
 
 using ScriptingFn = Result<ScriptingParam> (*)(
 	ClassSelf*, void*, const std::vector<ScriptingParam>&);
 
 enum class ScriptingType {
 	Void,
+	Bool,
 	Float,
 	Int,
 	String,
@@ -93,6 +94,13 @@ struct ScriptingTypeOfType<std::string_view> {
 	}
 };
 
+template <>
+struct ScriptingTypeOfType<bool> {
+	static ScriptingType value() {
+		return ScriptingType::Bool;
+	}
+};
+
 template <>
 struct ScriptingTypeOfType<int> {
 	static ScriptingType value() {

src/core/include/growl/core/input/event.h

@@ -52,11 +52,11 @@ class InputEvent {
 	InputEvent(InputEventType type, InputEventVariant event)
 		: type{type}
 		, event{event} {}
-	InputEventType getType() {
+	InputEventType getType() const {
 		return type;
 	}
 	template <class T>
-	Result<T> getEvent() noexcept {
+	Result<T> getEvent() const noexcept {
 		if (std::holds_alternative<T>(event)) {
 			return std::get<T>(event);
 		}

src/core/include/growl/core/input/processor.h

@@ -12,13 +12,24 @@ struct InputCustomEvent;
 class InputProcessor {
 public:
 	virtual ~InputProcessor() = 0;
-	virtual void onEvent(InputEvent& event);
+	virtual bool onEvent(const InputEvent& event);
 
-	virtual void onKeyboardEvent(InputKeyboardEvent& event) {}
-	virtual void onMouseEvent(InputMouseEvent& event) {}
-	virtual void onTouchEvent(InputTouchEvent& event) {}
-	virtual void onControllerEvent(InputControllerEvent& event) {}
-	virtual void onCustomEvent(InputCustomEvent& event) {}
+protected:
+	virtual bool onKeyboardEvent(const InputKeyboardEvent& event) {
+		return false;
+	}
+	virtual bool onMouseEvent(const InputMouseEvent& event) {
+		return false;
+	}
+	virtual bool onTouchEvent(const InputTouchEvent& event) {
+		return false;
+	}
+	virtual bool onControllerEvent(const InputControllerEvent& event) {
+		return false;
+	}
+	virtual bool onCustomEvent(const InputCustomEvent& event) {
+		return false;
+	}
 };
 
 } // namespace Growl

src/core/src/input/processor.cpp

@@ -10,37 +10,37 @@ using Growl::InputProcessor;
 // without any pure virtual functions.
 InputProcessor::~InputProcessor() {}
 
-void InputProcessor::onEvent(InputEvent& event) {
+bool InputProcessor::onEvent(const InputEvent& event) {
 	switch (event.getType()) {
 	case InputEventType::Keyboard: {
 		auto keyboard_event_result = event.getEvent<InputKeyboardEvent>();
 		if (keyboard_event_result.hasResult()) {
-			onKeyboardEvent(keyboard_event_result.get());
+			return onKeyboardEvent(keyboard_event_result.get());
 		}
-		return;
+		return false;
 	}
 	case InputEventType::Mouse: {
 		auto mouse_event_result = event.getEvent<InputMouseEvent>();
 		if (mouse_event_result.hasResult()) {
-			onMouseEvent(mouse_event_result.get());
+			return onMouseEvent(mouse_event_result.get());
 		}
-		return;
+		return false;
 	}
 	case InputEventType::Controller: {
 		auto controller_event_result = event.getEvent<InputControllerEvent>();
 		if (controller_event_result.hasResult()) {
-			onControllerEvent(controller_event_result.get());
+			return onControllerEvent(controller_event_result.get());
 		}
-		return;
+		return false;
 	}
 	case InputEventType::Touch: {
 		auto touch_event_result = event.getEvent<InputTouchEvent>();
 		if (touch_event_result.hasResult()) {
-			onTouchEvent(touch_event_result.get());
+			return onTouchEvent(touch_event_result.get());
 		}
-		return;
+		return false;
 	}
 	default:
-		return;
+		return false;
 	}
 }

src/plugins/lua/src/lua_scripting.cpp

@@ -64,8 +64,7 @@ int checkArgMetatable(lua_State* state, int arg, const char* metatable) {
 	return 0;
 }
 
-int luaPushArgs(
-	std::vector<ScriptingParam>& args, lua_State* state, LuaStack& stack) {
+int luaPushArgs(std::vector<ScriptingParam>& args, lua_State* state) {
 	int args_count = 0;
 	for (size_t i = 0; i < args.size(); i++) {
 		switch (static_cast<Growl::ScriptingType>(args[i].index())) {
@@ -87,6 +86,9 @@ int luaPushArgs(
 		case Growl::ScriptingType::Float:
 			lua_pushnumber(state, std::get<float>(args[i]));
 			break;
+		case Growl::ScriptingType::Bool:
+			lua_pushboolean(state, std::get<bool>(args[i]));
+			break;
 		case Growl::ScriptingType::Ref:
 			lua_rawgeti(
 				state, LUA_REGISTRYINDEX,
@@ -122,6 +124,9 @@ luaPullReturn(Growl::ScriptingType return_type, lua_State* state) {
 	case Growl::ScriptingType::Float:
 		ret = static_cast<float>(lua_tonumber(state, -1));
 		break;
+	case Growl::ScriptingType::Bool:
+		ret = static_cast<bool>(lua_toboolean(state, -1));
+		break;
 	case Growl::ScriptingType::Object:
 		return std::make_unique<Growl::LuaObject>(
 			state, luaL_ref(state, LUA_REGISTRYINDEX));
@@ -356,6 +361,12 @@ Error LuaScriptingAPI::addMethodToClass(
 						lua_tonumber(state, i + stack_offset));
 					break;
 				}
+				case ScriptingType::Ptr: {
+					luaL_checktype(state, i + stack_offset, LUA_TLIGHTUSERDATA);
+					args[i] = static_cast<const void*>(
+						lua_topointer(state, i + stack_offset));
+					break;
+				}
 				default:
 					continue;
 				}
@@ -394,6 +405,9 @@ Error LuaScriptingAPI::addMethodToClass(
 			case ScriptingType::Float:
 				lua_pushnumber(state, std::get<float>(*res));
 				return 1;
+			case ScriptingType::Bool:
+				lua_pushboolean(state, std::get<bool>(*res));
+				return 1;
 			}
 			return 0;
 		},
@@ -410,7 +424,7 @@ Result<ScriptingParam> LuaScriptingAPI::executeMethod(
 		this->state, LUA_REGISTRYINDEX, static_cast<LuaObject&>(obj).getRef());
 	lua_getfield(this->state, -1, method_name.c_str());
 	lua_pushvalue(this->state, -2);
-	int n_args = luaPushArgs(args, this->state, stack);
+	int n_args = luaPushArgs(args, this->state);
 	int n_returns = signature.return_type == ScriptingType::Void ? 0 : 1;
 	stack.stack_count += n_returns + 1;
 	if (lua_pcall(this->state, n_args + 1, n_returns, 0)) {

src/scene/include/growl/scene/node.h

@@ -35,7 +35,7 @@ class Node : public InputProcessor {
 	void draw(Batch& batch, float parent_alpha);
 	void drawChildren(Batch& batch, float parent_alpha);
 
-	virtual void onEvent(InputEvent& event) override;
+	virtual bool onEvent(const InputEvent& event) override;
 	bool hit(float x, float y);
 
 	Error bindScript(API& api, Script& script);

src/scene/src/node.cpp

@@ -88,11 +88,15 @@ void Node::drawChildren(Batch& batch, float parent_alpha) {
 	}
 }
 
-void Node::onEvent(InputEvent& event) {
-	InputProcessor::onEvent(event);
+bool Node::onEvent(const InputEvent& event) {
+	if (InputProcessor::onEvent(event)) {
+		return true;
+	}
+	bool handled = false;
 	for (auto& child : children) {
-		child->onEvent(event);
+		handled |= child->onEvent(event);
 	}
+	return handled;
 }
 
 bool Node::hit(float x, float y) {