Add aditional wren bindings

Author: OverShifted

OverEngine/src/OverEngine/Core/FileSystem/FileSystem.cpp

@@ -21,7 +21,7 @@ namespace OverEngine
 		}
 		else
 		{
-			OE_CORE_ASSERT("Could not open file '{0}'", path);
+			OE_CORE_ASSERT(false, "Could not open file '{0}'", path);
 		}
 
 		return result;

OverEngine/src/OverEngine/Input/Input.h

@@ -9,8 +9,10 @@ namespace OverEngine
 	class Input
 	{
 	public:
+		// TODO: Maybe merge these two functions?
 		static bool IsKeyPressed(KeyCode keycode);
 		static bool IsMouseButtonPressed(KeyCode button);
+
 		static Vector2 GetMousePosition();
 		static float GetMouseX();
 		static float GetMouseY();

OverEngine/src/OverEngine/Scripting/WrenBindings.cpp

@@ -9,43 +9,59 @@
 #include "OverEngine/Scene/TransformComponent.h"
 
 #define WRENPP_BIND_STATIC(f, sig) .bindFunction<decltype(&f), &f>(true, sig)
+#define WRENPP_BIND_STATIC_EXACT(f, args) .bindFunction<decltype(&f), &f>(true, #f "(" args ")")
+
 #define WRENPP_BIND_GETTER(f, sig) .bindGetter<decltype(f), &f>(sig)
 #define WRENPP_BIND_SETTER(f, sig) .bindSetter<decltype(f), &f>(sig)
+#define WRENPP_BIND_GETSET(klass, f) WRENPP_BIND_GETTER(klass::f, #f) WRENPP_BIND_SETTER(klass::f, #f "=(_)")
 
 namespace OverEngine
 {
 	namespace WrenBindings
 	{
-		bool Input_isKeyPressed(double keycode)
+		#define WREN_INPUT(name, wrenParams, nativeCallParams)            \
+			auto Input_##name(wrenParams) \
+			{                                                                \
+				return Input::name(nativeCallParams);                \
+			}
+
+		WREN_INPUT(IsKeyPressed, int keycode, (KeyCode)keycode)
+		WREN_INPUT(IsMouseButtonPressed, int keycode, (KeyCode)keycode)
+		WREN_INPUT(GetMousePosition,,)
+		WREN_INPUT(GetMouseX,,)
+		WREN_INPUT(GetMouseY,,)
+
+		#define WREN_COMPONENT_HAS(component)                 \
+			bool component##_has(Entity& entity)         \
+			{                                            \
+				return entity.HasComponent<component>(); \
+			}
+
+		WREN_COMPONENT_HAS(NameComponent)
+		WREN_COMPONENT_HAS(TransformComponent)
+		WREN_COMPONENT_HAS(RigidBody2DComponent)
+
+		const String& NameComponent_name(Entity& entity)
 		{
-			return Input::IsKeyPressed((KeyCode)keycode);
+			return entity.GetComponent<NameComponent>().Name;
 		}
 
-		String EntityInternals_getName(Entity& entity)
+		void NameComponent_set_name(Entity& entity, const String& name)
 		{
-			return entity.GetComponent<NameComponent>().Name;
+			entity.GetComponent<NameComponent>().Name = name;
 		}
 
-		Vector3 EntityInternals_getPosition(Entity& entity)
+		Vector3 TransformComponent_position(Entity& entity)
 		{
 			return entity.GetComponent<TransformComponent>().GetPosition();
 		}
 
-		void EntityInternals_setPosition(Entity& entity, const Vector3& position)
+		void TransformComponent_set_position(Entity& entity, const Vector3& position)
 		{
 			entity.GetComponent<TransformComponent>().SetPosition(position);
 		}
 
-		#define COMPONENT_HAS(component)                 \
-			bool component##_has(Entity& entity)         \
-			{                                            \
-				return entity.HasComponent<component>(); \
-			}
-
-		COMPONENT_HAS(TransformComponent)
-		COMPONENT_HAS(RigidBody2DComponent)
-
-		void RigidBody2DComponent_applyLinearImpulseToCenter(Entity& entity, const Vector3& impulse)
+		void RigidBody2DComponent_applyLinearImpulseToCenter(Entity& entity, const Vector2& impulse)
 		{
 			entity.GetComponent<RigidBody2DComponent>().RigidBody->ApplyLinearImpulseToCenter(impulse);
 		}
@@ -57,44 +73,49 @@ namespace OverEngine
 
 		m_VM.beginModule("input")
 			.beginClass("Input")
-				WRENPP_BIND_STATIC(Input_isKeyPressed, "isKeyPressed(_)")
+				WRENPP_BIND_STATIC(Input_IsKeyPressed, "isKeyPressed(_)")
+				WRENPP_BIND_STATIC(Input_IsMouseButtonPressed, "isMouseButtonPressed(_)")
+				
+				WRENPP_BIND_STATIC(Input_GetMousePosition, "mousePosition")
+				WRENPP_BIND_STATIC(Input_GetMouseX, "mouseX")
+				WRENPP_BIND_STATIC(Input_GetMouseY, "mouseY")
 			.endClass()
 		.endModule();
 
 		m_VM.beginModule("entity")
-			.beginClass("EntityInternals")
-				WRENPP_BIND_STATIC(EntityInternals_getName, "getName(_)")
-				WRENPP_BIND_STATIC(EntityInternals_getPosition, "getPosition(_)")
-				WRENPP_BIND_STATIC(EntityInternals_setPosition, "setPosition(_,_)")
-			.endClass()
-
 			.bindClass<Entity>("Entity")
 			.endClass()
 		.endModule();
 
 		m_VM.beginModule("components")
 			.beginClass("ComponentInternals")
-				WRENPP_BIND_STATIC(RigidBody2DComponent_applyLinearImpulseToCenter, "RigidBody2DComponent_applyLinearImpulseToCenter(_,_)")
-			.endClass()
+				WRENPP_BIND_STATIC_EXACT(NameComponent_name, "_")
+				WRENPP_BIND_STATIC_EXACT(NameComponent_set_name, "_,_")
 
-			.beginClass("TransformComponent")
-				WRENPP_BIND_STATIC(TransformComponent_has, "has(_)")
-			.endClass()
+				WRENPP_BIND_STATIC_EXACT(TransformComponent_position, "_")
+				WRENPP_BIND_STATIC_EXACT(TransformComponent_set_position, "_,_")
 
-			.beginClass("RigidBody2DComponent")
-				WRENPP_BIND_STATIC(RigidBody2DComponent_has, "has(_)")
+				WRENPP_BIND_STATIC_EXACT(RigidBody2DComponent_applyLinearImpulseToCenter, "_,_")
 			.endClass()
+
+			#define BIND_WREN_COMPONENT_HAS(component) .beginClass(#component) WRENPP_BIND_STATIC(component##_has, "has(_)").endClass()
+
+			BIND_WREN_COMPONENT_HAS(NameComponent)
+			BIND_WREN_COMPONENT_HAS(TransformComponent)
+			BIND_WREN_COMPONENT_HAS(RigidBody2DComponent)
+
 		.endModule();
 
 		m_VM.beginModule("math")
 			.bindClass<Vector3, float, float, float>("Vector3")
-				WRENPP_BIND_GETTER(Vector3::x, "x")
-				WRENPP_BIND_GETTER(Vector3::y, "y")
-				WRENPP_BIND_GETTER(Vector3::z, "z")
+				WRENPP_BIND_GETSET(Vector3, x)
+				WRENPP_BIND_GETSET(Vector3, y)
+				WRENPP_BIND_GETSET(Vector3, z)
+			.endClass()
 
-				WRENPP_BIND_SETTER(Vector3::x, "x=(_)")
-				WRENPP_BIND_SETTER(Vector3::y, "y=(_)")
-				WRENPP_BIND_SETTER(Vector3::z, "z=(_)")
+			.bindClass<Vector2, float, float>("Vector2")
+				WRENPP_BIND_GETSET(Vector2, x)
+				WRENPP_BIND_GETSET(Vector2, y)
 			.endClass()
 		.endModule();
 

OverEngine/src/Wren/components.wren

@@ -1,17 +1,40 @@
 class ComponentInternals {
+	foreign static NameComponent_name(entity)
+	foreign static NameComponent_set_name(entity, name)
+
+	foreign static TransformComponent_position(entity)
+	foreign static TransformComponent_set_position(entity, position)
+
 	foreign static RigidBody2DComponent_applyLinearImpulseToCenter(entity, impulse)
 }
 
-class TransformComponent {
+class Component {
+	construct new(entity) { _entity = entity }
+	entity { _entity }
+}
+
+class NameComponent is Component {
+	// Private to engine
 	foreign static has(entity)
+	construct new(entity) { super(entity) }
 
-	construct new(entity) { _entity = entity }
+	name { ComponentInternals.NameComponent_name(entity) }
+	name=(rhs) { ComponentInternals.NameComponent_set_name(entity, rhs) }
 }
 
-class RigidBody2DComponent {
+class TransformComponent is Component {
+	// Private to engine
 	foreign static has(entity)
+	construct new(entity) { super(entity) }
 
-	construct new(entity) { _entity = entity }
+	position { ComponentInternals.TransformComponent_position(entity) }
+	position=(rhs) { ComponentInternals.TransformComponent_set_position(entity, rhs) }
+}
+
+class RigidBody2DComponent is Component {
+	// Private to engine
+	foreign static has(entity)
+	construct new(entity) { super(entity) }
 
-	applyLinearImpulseToCenter(impulse) { ComponentInternals.RigidBody2DComponent_applyLinearImpulseToCenter(_entity, impulse) }
+	applyLinearImpulseToCenter(impulse) { ComponentInternals.RigidBody2DComponent_applyLinearImpulseToCenter(entity, impulse) }
 }

OverEngine/src/Wren/entity.wren

@@ -1,19 +1,13 @@
-#nodoc
-class EntityInternals {
-	foreign static getName(entity)
-	foreign static getPosition(entity)
-	foreign static setPosition(entity, position)
-}
+import "components" for NameComponent, TransformComponent
 
 /// A single entity in the scene.
 foreign class Entity {
 	/// The name of the entity.
 	/// Under the hood, its stored in NameComponent.
-	name { EntityInternals.getName(this) }
+	name { getComponent(NameComponent).name }
+	toString { "Entity(\"%(name)\")" }
 
-	/// Position of the entity in spatial space.
-	position { EntityInternals.getPosition(this) }
-	position=(rhs) { EntityInternals.setPosition(this, rhs) }
+	transform { getComponent(TransformComponent) }
 
 	hasComponent(type) { type.has(this) }
 	getComponent(type) {

OverEngine/src/Wren/input.wren

@@ -1,3 +1,8 @@
 class Input {
 	foreign static isKeyPressed(keycode)
+	foreign static isMouseButtonPressed(keycode)
+
+	foreign static mousePosition
+	foreign static mouseX
+	foreign static mouseY
 }

OverEngine/src/Wren/math.wren

@@ -1,3 +1,7 @@
+class Math {
+	static lerp(a, b, t) { a * (1 - t) + b * t }
+}
+
 foreign class Vector3 {
 	construct new(x, y, z) {}
 
@@ -13,6 +17,19 @@ foreign class Vector3 {
 
 	*(rhs) { Vector3.new(x * rhs, y * rhs, z * rhs) }
 	+(rhs) { Vector3.new(x + rhs.x, y + rhs.y, z + rhs.z) }
+}
+
+foreign class Vector2 {
+	construct new(x, y) {}
+
+	foreign x
+	foreign y
+
+	foreign x=(rhs)
+	foreign y=(rhs)
+
+	toString { "Vector2(%(x), %(y))" }
 
-	lerp(b, t) { this * (1 - t) + b * t }
+	*(rhs) { Vector2.new(x * rhs, y * rhs) }
+	+(rhs) { Vector2.new(x + rhs.x, y + rhs.y) }
 }

OverEngine/src/Wren/script.wren

@@ -6,6 +6,8 @@ class Script {
 	}
 
 	entity { _entity }
+	name { _entity.name }
+	transform { _entity.transform }
 
 	onCreate() {}
 	onDestroy() {}

Sandbox/src/wren/scripts.wren

@@ -1,7 +1,7 @@
 import "script" for Script
 import "keycodes" for KeyCode
 import "input" for Input
-import "math" for Vector3
+import "math" for Math, Vector2
 import "components" for RigidBody2DComponent
 
 class Player is Script {
@@ -15,14 +15,16 @@ class Player is Script {
 	}
 
 	onUpdate(delta) {
-		var impulse = Vector3.new(0, 0, 0)
+		var impulse = Vector2.new(0, 0)
 
 		if (Input.isKeyPressed(KeyCode.a)) { impulse.x = impulse.x - 1 }
 		if (Input.isKeyPressed(KeyCode.d)) { impulse.x = impulse.x + 1 }
 		if (Input.isKeyPressed(KeyCode.w)) { impulse.y = impulse.y + 1 }
 		if (Input.isKeyPressed(KeyCode.s)) { impulse.y = impulse.y - 1 }
 
 		_rb.applyLinearImpulseToCenter(impulse * 20 * delta)
+
+		System.print("%(Input.mouseX) %(Input.mouseY) %(Input.mousePosition)")
 	}
 }
 
@@ -34,6 +36,6 @@ class CameraController is Script {
 	player=(rhs) { _player = rhs }
 
 	onLateUpdate(delta) {
-		entity.position = _player.position.lerp(entity.position, 0.5)
+		transform.position = Math.lerp(_player.transform.position, transform.position, 0.5)
 	}
 }