ScriptCore: Added more properties to components

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

GlitchyEditor/src/EditWindows/ComponentEditWindow.bf

@@ -436,6 +436,12 @@ namespace GlitchyEditor.EditWindows
 			{
 				rigidBodyComponent.FixedRotation = isFixedRotation;
 			}
+
+			float gravityScale = rigidBodyComponent.GravityScale;
+			if (ImGui.DragFloat("Gravity Scale", &gravityScale))
+			{
+				rigidBodyComponent.GravityScale = gravityScale;
+			}
 		}
 
 		private static void ShowBoxCollider2DComponentEditor(Entity entity, BoxCollider2DComponent* boxCollider)

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;
 
@@ -368,6 +388,20 @@ namespace GlitchyEngine.World
 			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
 		{
 			get => _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":

ScriptCore/Core/Transform.cs

@@ -1,3 +1,4 @@
+using System.Numerics;
 using GlitchyEngine.Math;
 
 namespace GlitchyEngine.Core;
@@ -35,4 +36,56 @@ public class Transform : Component
         }
         set => ScriptGlue.Transform_SetTranslation(Entity.UUID, in value);
     }
+
+    /// <summary>
+    /// Gets or sets the rotation of the entity.
+    /// </summary>
+    public Quaternion Rotation
+    {
+        get
+        {
+            ScriptGlue.Transform_GetRotation(Entity.UUID, out Quaternion rotation);
+            return rotation;
+        }
+        set => ScriptGlue.Transform_SetRotation(Entity.UUID, in value);
+    }
+
+    /// <summary>
+    /// Gets or sets the rotation of the entity in radians around each axis.
+    /// </summary>
+    public float3 RotationEuler
+    {
+        get
+        {
+            ScriptGlue.Transform_GetRotationEuler(Entity.UUID, out float3 rotationEuler);
+            return rotationEuler;
+        }
+        set => ScriptGlue.Transform_SetRotationEuler(Entity.UUID, in value);
+    }
+
+    /// <summary>
+    /// Gets or sets the rotation of the entity as an axis of rotation and the angle in radians.
+    /// </summary>
+    public RotationAxisAngle RotationAxisAngle
+    {
+        get
+        {
+            ScriptGlue.Transform_GetRotationAxisAngle(Entity.UUID, out RotationAxisAngle rotationEuler);
+            return rotationEuler;
+        }
+        set => ScriptGlue.Transform_SetRotationAxisAngle(Entity.UUID, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the scale of the entity.
+    /// </summary>
+    public float3 Scale
+    {
+        get
+        {
+            ScriptGlue.Transform_GetScale(Entity.UUID, out float3 scale);
+            return scale;
+        }
+        set => ScriptGlue.Transform_SetScale(Entity.UUID, in value);
+    }
 }

ScriptCore/Graphics/CircleRenderer.cs

@@ -0,0 +1,51 @@
+using GlitchyEngine.Core;
+using GlitchyEngine.Math;
+
+namespace GlitchyEngine.Graphics;
+
+/// <summary>
+/// Component that renders a circle.
+/// </summary>
+public class CircleRenderer : Component
+{
+	// TODO: Texture2D Sprite
+
+    /// <summary>
+    /// Gets or sets the tint color of the circle.
+    /// </summary>
+    public ColorRGBA Color
+    {
+        get
+        {
+            ScriptGlue.CircleRenderer_GetColor(_uuid, out ColorRGBA color);
+            return color;
+        }
+        set => ScriptGlue.CircleRenderer_SetColor(_uuid, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the UV transform for the texture. XY are an offset, ZW are scaling
+    /// </summary>
+    public float4 UvTransform
+    {
+        get
+        {
+            ScriptGlue.CircleRenderer_GetUvTransform(_uuid, out float4 uvTransform);
+            return uvTransform;
+        }
+        set => ScriptGlue.CircleRenderer_SetUvTransform(_uuid, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the inner radius of the torus. 0 means a circle is rendered.
+    /// </summary>
+    public float InnerRadius
+    {
+        get
+        {
+            ScriptGlue.CircleRenderer_GetInnerRadius(_uuid, out float innerRadius);
+            return innerRadius;
+        }
+        set => ScriptGlue.CircleRenderer_SetInnerRadius(_uuid, value);
+    }
+}

ScriptCore/Math/ColorRGBA.cs

@@ -0,0 +1,65 @@
+using System.Runtime.InteropServices;
+
+namespace GlitchyEngine.Math;
+
+using static GlitchyEngine.Math.Math;
+
+/// <summary>
+/// Represents a color with red, blue, green color channels and alpha.
+/// <br/>Each channel is represented by a <see cref="float"/>
+/// </summary>
+[StructLayout(LayoutKind.Sequential, Pack=1)]
+public struct ColorRGBA
+{
+    internal const float SrgbToLin = 2.2f;
+    internal const float LinToSRGB = (float)(1.0 / 2.2);
+
+    /// <summary>
+    /// The red component of the color.
+    /// </summary>
+    public float R;
+    
+    /// <summary>
+    /// The green component of the color.
+    /// </summary>
+    public float G;
+    
+    /// <summary>
+    /// The blue component of the color.
+    /// </summary>
+    public float B;
+    
+    /// <summary>
+    /// The alpha component of the color.
+    /// </summary>
+    public float A;
+
+    /// <summary>
+    /// Creates a new instance of ColorRGBA with all components set to 0.
+    /// </summary>
+    public ColorRGBA() { }
+
+    /// <summary>
+    /// Creates a new instance of ColorRGBA with the specified values.
+    /// </summary>
+    /// <param name="r">The red component of the color.</param>
+    /// <param name="g">The green component of the color.</param>
+    /// <param name="b">The blue component of the color.</param>
+    /// <param name="a">The alpha component of the color.</param>
+    public ColorRGBA(float r, float g, float b, float a = 1.0f)
+    {
+        R = r;
+        G = g;
+        B = b;
+        A = a;
+    }
+
+    public static explicit operator float4(ColorRGBA color) => new float4(color.R, color.G, color.B, color.A);
+    public static explicit operator ColorRGBA(float4 vector) => new ColorRGBA(vector.X, vector.Y, vector.Z, vector.W);
+    
+    // Converts a Color from sRGB color space to Linear color space.
+    public static ColorRGBA SRgbToLinear(ColorRGBA sRGB) => new ColorRGBA(pow(sRGB.R, SrgbToLin), pow(sRGB.G, SrgbToLin), pow(sRGB.B, SrgbToLin), sRGB.A);
+
+    // Converts a Color from linear color space to sRGB color space.
+    public static ColorRGBA LinearToSRGB(ColorRGBA linear) => new ColorRGBA(pow(linear.R, LinToSRGB), pow(linear.G, LinToSRGB), pow(linear.B, LinToSRGB), linear.A);
+}

ScriptCore/Math/RotationAxisAngle.cs

@@ -0,0 +1,30 @@
+using System.Runtime.InteropServices;
+
+namespace GlitchyEngine.Math;
+
+/// <summary>
+/// Represents a rotation around an axis by a specific angle.
+/// </summary>
+[StructLayout(LayoutKind.Sequential, Pack=1)]
+public struct RotationAxisAngle
+{
+    /// <summary>
+    /// The axis around which the rotation is applied.
+    /// </summary>
+    public float3 Axis;
+    /// <summary>
+    /// The angle in radians around the <see cref="Axis"/>.
+    /// </summary>
+    public float Angle;
+
+    /// <summary>
+    /// Creates a new instance of an axis angle rotation.
+    /// </summary>
+    /// <param name="axis">The axis.</param>
+    /// <param name="angle">The angle in radians.</param>
+    public RotationAxisAngle(float3 axis, float angle)
+    {
+        Axis = axis;
+        Angle = angle;
+    }
+}

ScriptCore/Physics/BodyType.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GlitchyEngine.Physics;
+
+/// <summary>
+/// Describes whether the rigid body is static, dynamic or kinematic.
+/// </summary>
+public enum BodyType : byte
+{
+    /// <summary>
+    /// A static body does not move under simulation and behaves as if it has infinite mass.
+    /// Internally, Box2D stores zero for the mass and the inverse mass
+    /// Static bodies can be moved manually by the user. A static body has zero velocity. 
+    /// Static bodies do not collide with other static or kinematic bodies.
+    /// </summary>
+    Static = 0,
+    /// <summary>
+    /// A dynamic body is fully simulated. They can be moved manually by the user, but normally they move according to forces.
+    /// A dynamic body can collide with all body types. A dynamic body always has finite, non-zero mass.
+    /// If you try to set the mass of a dynamic body to zero, it will automatically acquire a mass of one kilogram and it won't rotate.
+    /// </summary>
+    Dynamic = 1,
+    /// <summary>
+    /// A kinematic body moves under simulation according to its velocity.
+    /// Kinematic bodies do not respond to forces. They can be moved manually by the user, but normally a kinematic body is moved by setting its velocity.
+    /// A kinematic body behaves as if it has infinite mass, however, Box2D stores zero for the mass and the inverse mass.
+    /// Kinematic bodies do not collide with other kinematic or static bodies.
+    /// </summary>
+    Kinematic = 2
+}

ScriptCore/Physics/Rigidbody2D.cs

@@ -101,4 +101,34 @@ public class Rigidbody2D : Component
         }
         set => ScriptGlue.Rigidbody2D_SetFixedRotation(_uuid, value);
     }
+
+    /// <summary>
+    /// Gets or sets the body type of the rigidbody.
+    /// </summary>
+    public BodyType BodyType
+    {
+        get
+        {
+            ScriptGlue.Rigidbody2D_GetBodyType(_uuid, out BodyType bodyType);
+
+            return bodyType;
+        }
+        set => ScriptGlue.Rigidbody2D_SetBodyType(_uuid, value);
+    }
+    
+
+    /// <summary>
+    /// Gets or sets the gravity scale of this rigidbody.
+    /// E.g. a value of 0.0 means, that the rigidbody is not affected by gravity and a value of -1.0 means, that it gravity is inverted.
+    /// </summary>
+    public float GravityScale
+    {
+        get
+        {
+            ScriptGlue.Rigidbody2D_GetGravityScale(_uuid, out float gravityScale);
+
+            return gravityScale;
+        }
+        set => ScriptGlue.Rigidbody2D_SetGravityScale(_uuid, value);
+    }
 }

ScriptCore/ScriptGlue.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using GlitchyEngine.Core;
 using GlitchyEngine.Math;
+using GlitchyEngine.Physics;
 using GlitchyEngine.Serialization;
 
 namespace GlitchyEngine;
@@ -79,6 +81,30 @@ internal static class ScriptGlue
     [MethodImpl(MethodImplOptions.InternalCall)]
     internal static extern void Transform_SetTranslation(UUID entityId, in float3 translation);
     
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_GetRotation(UUID entityId, out Quaternion rotation);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_SetRotation(UUID entityId, in Quaternion rotation);
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_GetRotationEuler(UUID entityId, out float3 rotationEuler);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_SetRotationEuler(UUID entityId, in float3 rotationEuler);
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_GetRotationAxisAngle(UUID entityId, out RotationAxisAngle translation);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_SetRotationAxisAngle(UUID entityId, RotationAxisAngle translation);
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_GetScale(UUID entityId, out float3 scale);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Transform_SetScale(UUID entityId, in float3 scale);
+
 #endregion TransformComponent
 
 #region RigidBody2D
@@ -113,12 +139,24 @@ internal static class ScriptGlue
     [MethodImpl(MethodImplOptions.InternalCall)]
     internal static extern void Rigidbody2D_GetAngularVelocity(UUID entityId, out float velocity);
     
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Rigidbody2D_GetBodyType(UUID entityId, out BodyType bodyType);
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Rigidbody2D_SetBodyType(UUID entityId, in BodyType bodyType);
+
     [MethodImpl(MethodImplOptions.InternalCall)]
     internal static extern void Rigidbody2D_IsFixedRotation(UUID entityId, out bool isFixedRotation);
 
     [MethodImpl(MethodImplOptions.InternalCall)]
     internal static extern void Rigidbody2D_SetFixedRotation(UUID entityId, in bool isFixedRotation);
     
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Rigidbody2D_GetGravityScale(UUID entityId, out float gravityScale);
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void Rigidbody2D_SetGravityScale(UUID entityId, in float gravityScale);
+    
 #endregion RigidBody2D
 
 #region Camera
@@ -182,6 +220,28 @@ internal static class ScriptGlue
 
 #endregion Physics2D
 
+#region CircleRenderer
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void CircleRenderer_GetColor(UUID entityId, out ColorRGBA color);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void CircleRenderer_SetColor(UUID entityId, ColorRGBA color);
+    
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void CircleRenderer_GetUvTransform(UUID entityId, out float4 uvTransform);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void CircleRenderer_SetUvTransform(UUID entityId, float4 uvTransform);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void CircleRenderer_GetInnerRadius(UUID entityId, out float innerRadius);
+
+    [MethodImpl(MethodImplOptions.InternalCall)]
+    internal static extern void CircleRenderer_SetInnerRadius(UUID entityId, float innerRadius);
+
+#endregion
+
 #region Math
     
     [MethodImpl(MethodImplOptions.InternalCall)]