ScriptCore: Added more properties to components

- Added CircleRenderer
- Transform: Added Rotation, RotationEuler, RotationAxisAngle and Scale
- RigidBody: Added BodyType and GravityScale
- Added ColorRGBA

GlitchyEngine/src/Scripting/ScriptGlue.bf

@@ -88,12 +88,12 @@ static class ScriptGlue
 		RegisterComponent<TransformComponent>("GlitchyEngine.Core.Transform");
 		RegisterComponent<Rigidbody2DComponent>("GlitchyEngine.Physics.Rigidbody2D");
 		RegisterComponent<CameraComponent>("GlitchyEngine.Core.Camera");
+		RegisterComponent<CircleRendererComponent>("GlitchyEngine.Graphics.CircleRenderer");
 	}
 
 	[RegisterMethod]
 	private static void RegisterCalls()
 	{
-		// Generated at CompTime
 	}
 
 	private static void RegisterComponent<T>(StringView cSharpClassName = "") where T : struct, new
@@ -498,6 +498,105 @@ static class ScriptGlue
 		{
 			rigidbody2D.SetPosition(translation.XY);
 		}
+		// TODO: we need to handle repositioning of colliders that are children of the entity with rigidbody...
+	}
+	
+	[RegisterCall("ScriptGlue::Transform_GetRotation")]
+	static void Transform_GetRotation(UUID entityId, out Quaternion rotation)
+	{
+		Entity entity = GetEntitySafe(entityId);
+
+		rotation = entity.Transform.Rotation;
+	}
+
+	[RegisterCall("ScriptGlue::Transform_SetRotation")]
+	static void Transform_SetRotation(UUID entityId, in Quaternion rotation)
+	{
+		Entity entity = GetEntitySafe(entityId);
+		
+		entity.Transform.Rotation = rotation;
+
+		if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
+		{
+			rigidbody2D.SetAngle(entity.Transform.RotationEuler.Z);
+		}
+		// TODO: When rotating around the X- or Y-axis we need to deform and reposition the colliders accordingly...
+	}
+	
+	[RegisterCall("ScriptGlue::Transform_GetRotationEuler")]
+	static void Transform_GetRotationEuler(UUID entityId, out float3 rotationEuler)
+	{
+		Entity entity = GetEntitySafe(entityId);
+
+		rotationEuler = entity.Transform.RotationEuler;
+	}
+
+	[RegisterCall("ScriptGlue::Transform_SetRotationEuler")]
+	static void Transform_SetRotationEuler(UUID entityId, in float3 rotationEuler)
+	{
+		Entity entity = GetEntitySafe(entityId);
+		
+		entity.Transform.RotationEuler = rotationEuler;
+
+		if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
+		{
+			rigidbody2D.SetAngle(rotationEuler.Z);
+		}
+	}
+
+	[Packed]
+	struct AxisAngle
+	{
+		public float3 Axis;
+		public float Angle;
+
+		public this((float3 Axis, float Angle) axisAngle)
+		{
+			Axis = axisAngle.Axis;
+			Angle = axisAngle.Angle;
+		}
+	}
+
+	[RegisterCall("ScriptGlue::Transform_GetRotationAxisAngle")]
+	static void Transform_GetRotationAxisAngle(UUID entityId, out AxisAngle rotationAxisAngle)
+	{
+		Entity entity = GetEntitySafe(entityId);
+
+		rotationAxisAngle = AxisAngle(entity.Transform.RotationAxisAngle);
+	}
+
+	[RegisterCall("ScriptGlue::Transform_SetRotationAxisAngle")]
+	static void Transform_SetRotationAxisAngle(UUID entityId, AxisAngle rotationAxisAngle)
+	{
+		Entity entity = GetEntitySafe(entityId);
+		
+		entity.Transform.RotationAxisAngle = (rotationAxisAngle.Axis, rotationAxisAngle.Angle);
+
+		if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
+		{
+			rigidbody2D.SetAngle(entity.Transform.RotationEuler.Z);
+		}
+	}
+
+	[RegisterCall("ScriptGlue::Transform_GetScale")]
+	static void Transform_GetScale(UUID entityId, out float3 scale)
+	{
+		Entity entity = GetEntitySafe(entityId);
+
+		scale = entity.Transform.Scale;
+	}
+
+	[RegisterCall("ScriptGlue::Transform_SetScale")]
+	static void Transform_SetScale(UUID entityId, float3 scale)
+	{
+		Entity entity = GetEntitySafe(entityId);
+		
+		entity.Transform.Scale = scale;
+
+		if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
+		{
+			// TODO: we need to scale and reposition the colliders, this is a mess...
+		}
 	}
 
 #endregion TransformComponent
@@ -574,6 +673,20 @@ static class ScriptGlue
 		rigidBody.SetAngularVelocity(velocity);
 	}
 
+	[RegisterCall("ScriptGlue::Rigidbody2D_GetBodyType")]
+	static void Rigidbody2D_GetBodyType(UUID entityId, out Rigidbody2DComponent.BodyType bodyType)
+	{
+		Rigidbody2DComponent* rigidBody = GetComponentSafe<Rigidbody2DComponent>(entityId);
+		bodyType = rigidBody.BodyType;
+	}
+	
+	[RegisterCall("ScriptGlue::Rigidbody2D_SetBodyType")]
+	static void Rigidbody2D_SetBodyType(UUID entityId, in Rigidbody2DComponent.BodyType bodyType)
+	{
+		Rigidbody2DComponent* rigidBody = GetComponentSafe<Rigidbody2DComponent>(entityId);
+		rigidBody.BodyType = bodyType;
+	}
+
 	[RegisterCall("ScriptGlue::Rigidbody2D_IsFixedRotation")]
 	static void Rigidbody2D_IsFixedRotation(UUID entityId, out bool isFixedRotation)
 	{
@@ -588,6 +701,20 @@ static class ScriptGlue
 		rigidBody.FixedRotation = isFixedRotation;
 	}
 
+	[RegisterCall("ScriptGlue::Rigidbody2D_GetGravityScale")]
+	static void Rigidbody2D_GetGravityScale(UUID entityId, out float gravityScale)
+	{
+		Rigidbody2DComponent* rigidBody = GetComponentSafe<Rigidbody2DComponent>(entityId);
+		gravityScale = rigidBody.GravityScale;
+	}
+	
+	[RegisterCall("ScriptGlue::Rigidbody2D_SetGravityScale")]
+	static void Rigidbody2D_SetGravityScale(UUID entityId, in float gravityScale)
+	{
+		Rigidbody2DComponent* rigidBody = GetComponentSafe<Rigidbody2DComponent>(entityId);
+		rigidBody.GravityScale = gravityScale;
+	}
+
 #endregion Rigidbody2D
 
 #region Camera
@@ -742,6 +869,52 @@ static class ScriptGlue
 
 #endregion Physics2D
 
+#region CircleRenderer
+	
+	[RegisterCall("ScriptGlue::CircleRenderer_GetColor")]
+	static void CircleRenderer_GetColor(UUID entityId, out ColorRGBA color)
+	{
+		CircleRendererComponent* circleRenderer = GetComponentSafe<CircleRendererComponent>(entityId);
+		color = circleRenderer.Color;
+	}
+
+	[RegisterCall("ScriptGlue::CircleRenderer_SetColor")]
+	static void CircleRenderer_SetColor(UUID entityId, ColorRGBA color)
+	{
+		CircleRendererComponent* circleRenderer = GetComponentSafe<CircleRendererComponent>(entityId);
+		circleRenderer.Color = color;
+	}
+	
+	[RegisterCall("ScriptGlue::CircleRenderer_GetUvTransform")]
+	static void CircleRenderer_GetUvTransform(UUID entityId, out float4 uvTransform)
+	{
+		CircleRendererComponent* circleRenderer = GetComponentSafe<CircleRendererComponent>(entityId);
+		uvTransform = circleRenderer.UvTransform;
+	}
+
+	[RegisterCall("ScriptGlue::CircleRenderer_SetUvTransform")]
+	static void CircleRenderer_SetUvTransform(UUID entityId, float4 uvTransform)
+	{
+		CircleRendererComponent* circleRenderer = GetComponentSafe<CircleRendererComponent>(entityId);
+		circleRenderer.UvTransform = uvTransform;
+	}
+	
+	[RegisterCall("ScriptGlue::CircleRenderer_GetInnerRadius")]
+	static void CircleRenderer_GetInnerRadius(UUID entityId, out float innerRadius)
+	{
+		CircleRendererComponent* circleRenderer = GetComponentSafe<CircleRendererComponent>(entityId);
+		innerRadius = circleRenderer.InnerRadius;
+	}
+
+	[RegisterCall("ScriptGlue::CircleRenderer_GetInnerRadius")]
+	static void CircleRenderer_GetInnerRadius(UUID entityId, float innerRadius)
+	{
+		CircleRendererComponent* circleRenderer = GetComponentSafe<CircleRendererComponent>(entityId);
+		circleRenderer.InnerRadius = innerRadius;
+	}
+
+#endregion
+
 #region Math
 
 	private static void RegisterMathFunctions()

GlitchyEngine/src/World/Components/Components.bf

@@ -349,11 +349,31 @@ namespace GlitchyEngine.World
 
 	struct Rigidbody2DComponent : IDisposableComponent
 	{
-		public enum BodyType { Static = 0, Dynamic = 1, Kinematic = 2 }
+		public enum BodyType
+		{
+			case Static = 0; case Dynamic = 1; case Kinematic = 2;
 
-		public BodyType BodyType = .Static;
+			public b2BodyType GetBox2DBodyType()
+			{
+				switch (this)
+				{
+				case .Static:
+					return .b2_staticBody;
+				case .Dynamic:
+					return .b2_dynamicBody;
+				case .Kinematic:
+					return .b2_kinematicBody;
+				default:
+					Log.EngineLogger.AssertDebug(false, "Unknown body type");
+					return .b2_staticBody;
+				}
+			}
+		}
 
-		public bool _fixedRotation = false;
+		private BodyType _bodyType = .Static;
+
+		private bool _fixedRotation = false;
+		private float _gravityScale = 1.0f;
 
 		private int _runtimeBody = 0;
 
@@ -367,6 +387,20 @@ namespace GlitchyEngine.World
 			[Inline]
 			set mut => _runtimeBody = (int)(void*)value;
 		}
+
+		public BodyType BodyType
+		{
+			get => _bodyType;
+			set mut
+			{
+				_bodyType = value;
+
+				if (RuntimeBody != null)
+				{
+					Box2D.Body.SetBodyType(RuntimeBody, _bodyType.GetBox2DBodyType());
+				}
+			}
+		}
 		
 		public bool FixedRotation
 		{
@@ -382,6 +416,20 @@ namespace GlitchyEngine.World
 			}
 		}
 
+		public float GravityScale
+		{
+			get => _gravityScale;
+			set mut
+			{
+				_gravityScale = value;
+
+				if (RuntimeBody != null)
+				{
+					Box2D.Body.SetGravityScale(RuntimeBody, _gravityScale);
+				}
+			}
+		}
+
 		/*public float LinearDamping
 		{
 			get => _linearDamping;

GlitchyEngine/src/World/Scene.bf

@@ -204,22 +204,6 @@ namespace GlitchyEngine.World
 			}
 		}
 
-		static b2BodyType GetBox2DBodyType(Rigidbody2DComponent.BodyType bodyType)
-		{
-			switch (bodyType)
-			{
-			case .Static:
-				return .b2_staticBody;
-			case .Dynamic:
-				return .b2_dynamicBody;
-			case .Kinematic:
-				return .b2_kinematicBody;
-			default:
-				Log.EngineLogger.AssertDebug(false, "Unknown body type");
-				return .b2_staticBody;
-			}
-		}
-
 		/**
 		 * Starts the scene.
 		 * @param startRuntime If true, the script runtime will be started.
@@ -477,7 +461,7 @@ namespace GlitchyEngine.World
 			var transform = entity.Transform;
 
 			b2BodyDef def = .();
-			def.type = GetBox2DBodyType(rigidBody.BodyType);
+			def.type = rigidBody.BodyType.GetBox2DBodyType();
 			def.userData = (void*)(uint)entity.Handle;
 
 			// TODO: check how stable this is
@@ -488,7 +472,9 @@ namespace GlitchyEngine.World
 			def.angle = worldRotationEuler.Z;
 
 			b2Body* body = Box2D.World.CreateBody(_physicsWorld2D, &def);
+			// BodyType set above
 			Box2D.Body.SetFixedRotation(body, rigidBody.FixedRotation);
+			Box2D.Body.SetGravityScale(body, rigidBody.GravityScale);
 
 			rigidBody.RuntimeBody = body;
 		}

GlitchyEngine/src/World/SceneSerializer.bf

@@ -186,6 +186,8 @@ class SceneSerializer
 				Serialize.Value(writer, "BodyType", component.BodyType);
 
 				Serialize.Value(writer, "FixedRotation", component.FixedRotation);
+
+				Serialize.Value(writer, "GravityScale", component.GravityScale);
 			});
 
 			SerializeComponent<BoxCollider2DComponent>(writer, entity, "BoxCollider2D", scope (component) =>
@@ -584,13 +586,21 @@ class SceneSerializer
 			case "Rigidbody2D":
 				Try!(DeserializeComponent<Rigidbody2DComponent>(reader, entity, scope (component) =>
 				{
-					Deserialize.Value(reader, "BodyType", out component.BodyType);
+					Rigidbody2DComponent.BodyType bodyType = .Static;
+					Deserialize.Value(reader, "BodyType", out bodyType);
+					component.BodyType = bodyType;
+
 					reader.EntryEnd();
 
 					bool fixedRotation = false;
 					Deserialize.Value(reader, "FixedRotation", out fixedRotation);
 					component.FixedRotation = fixedRotation;
 
+					reader.EntryEnd();
+
+					Deserialize.Value<float>(reader, "GravityScale", let gravityScale);
+					component.GravityScale = gravityScale;
+
 					return .Ok;
 				}));
 			case "BoxCollider2D":