From b42f1f18818645c6077d3b1f7f7e8ae9bc9ec06d Mon Sep 17 00:00:00 2001 From: Syntriax Date: Sun, 19 Oct 2025 19:03:30 +0300 Subject: [PATCH] fix: added missing types for new primitives --- .../LiteNetLibCommunicatorBase.cs | 12 +++++- .../Packers/ColorHSVANetPacker.cs | 26 ++++++++++++ .../Packers/Line3DNetPacker.cs | 22 ++++++++++ .../Packers/Ray2DNetPacker.cs | 22 ++++++++++ .../Packers/Ray3DNetPacker.cs | 22 ++++++++++ .../Packers/Vector2DIntNetPacker.cs | 22 ++++++++++ .../Packers/Vector3DIntNetPacker.cs | 24 +++++++++++ .../Packers/Vector4DNetPacker.cs | 26 ++++++++++++ .../Primitives/ColorHSVAConverter.cs | 28 +++++++++++++ .../Converters/Primitives/Line3DConverter.cs | 41 +++++++++++++++++++ .../Converters/Primitives/Ray2DConverter.cs | 41 +++++++++++++++++++ .../Converters/Primitives/Ray3DConverter.cs | 41 +++++++++++++++++++ .../Primitives/Vector2DIntConverter.cs | 28 +++++++++++++ .../Primitives/Vector3DIntConverter.cs | 28 +++++++++++++ .../Primitives/Vector4DConverter.cs | 28 +++++++++++++ .../EngineExtensions/TweenLine3DExtensions.cs | 31 ++++++++++++++ .../EngineExtensions/TweenRay2DExtensions.cs | 31 ++++++++++++++ .../EngineExtensions/TweenRay3DExtensions.cs | 31 ++++++++++++++ .../TweenVector4DExtensions.cs | 24 +++++++++++ 19 files changed, 526 insertions(+), 2 deletions(-) create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorHSVANetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/Line3DNetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray2DNetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray3DNetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector2DIntNetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector3DIntNetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector4DNetPacker.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/ColorHSVAConverter.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Line3DConverter.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray2DConverter.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray3DConverter.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector2DIntConverter.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector3DIntConverter.cs create mode 100644 Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector4DConverter.cs create mode 100644 Engine.Systems/Tween/EngineExtensions/TweenLine3DExtensions.cs create mode 100644 Engine.Systems/Tween/EngineExtensions/TweenRay2DExtensions.cs create mode 100644 Engine.Systems/Tween/EngineExtensions/TweenRay3DExtensions.cs create mode 100644 Engine.Systems/Tween/EngineExtensions/TweenVector4DExtensions.cs diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibCommunicatorBase.cs b/Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibCommunicatorBase.cs index 12113e0..6319785 100644 --- a/Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibCommunicatorBase.cs +++ b/Engine.Integration/Engine.Integration.LiteNetLib/LiteNetLibCommunicatorBase.cs @@ -144,18 +144,26 @@ public abstract class LiteNetLibCommunicatorBase : Behaviour, INetworkCommunicat { // I know, ugly af. I need to find a better way netPacketProcessor.RegisterNestedType(AABB2DNetPacker.Write, AABB2DNetPacker.Read); + netPacketProcessor.RegisterNestedType(AABB3DNetPacker.Write, AABB3DNetPacker.Read); netPacketProcessor.RegisterNestedType(CircleNetPacker.Write, CircleNetPacker.Read); netPacketProcessor.RegisterNestedType(ColorHSVNetPacker.Write, ColorHSVNetPacker.Read); - netPacketProcessor.RegisterNestedType(ColorRGBANetPacker.Write, ColorRGBANetPacker.Read); + netPacketProcessor.RegisterNestedType(ColorHSVANetPacker.Write, ColorHSVANetPacker.Read); netPacketProcessor.RegisterNestedType(ColorRGBNetPacker.Write, ColorRGBNetPacker.Read); - netPacketProcessor.RegisterNestedType(Line2DEquationNetPacker.Write, Line2DEquationNetPacker.Read); + netPacketProcessor.RegisterNestedType(ColorRGBANetPacker.Write, ColorRGBANetPacker.Read); netPacketProcessor.RegisterNestedType(Line2DNetPacker.Write, Line2DNetPacker.Read); + netPacketProcessor.RegisterNestedType(Line2DEquationNetPacker.Write, Line2DEquationNetPacker.Read); + netPacketProcessor.RegisterNestedType(Line3DNetPacker.Write, Line3DNetPacker.Read); netPacketProcessor.RegisterNestedType(Projection1DNetPacker.Write, Projection1DNetPacker.Read); netPacketProcessor.RegisterNestedType(QuaternionNetPacker.Write, QuaternionNetPacker.Read); + netPacketProcessor.RegisterNestedType(Ray2DNetPacker.Write, Ray2DNetPacker.Read); + netPacketProcessor.RegisterNestedType(Ray3DNetPacker.Write, Ray3DNetPacker.Read); netPacketProcessor.RegisterNestedType(Shape2DNetPacker.Write, Shape2DNetPacker.Read); netPacketProcessor.RegisterNestedType(TriangleNetPacker.Write, TriangleNetPacker.Read); netPacketProcessor.RegisterNestedType(Vector2DNetPacker.Write, Vector2DNetPacker.Read); + netPacketProcessor.RegisterNestedType(Vector2DIntNetPacker.Write, Vector2DIntNetPacker.Read); netPacketProcessor.RegisterNestedType(Vector3DNetPacker.Write, Vector3DNetPacker.Read); + netPacketProcessor.RegisterNestedType(Vector3DIntNetPacker.Write, Vector3DIntNetPacker.Read); + netPacketProcessor.RegisterNestedType(Vector4DNetPacker.Write, Vector4DNetPacker.Read); } public INetworkCommunicator SubscribeToPackets(Event.EventHandler callback) diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorHSVANetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorHSVANetPacker.cs new file mode 100644 index 0000000..b0bcad3 --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/ColorHSVANetPacker.cs @@ -0,0 +1,26 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class ColorHSVANetPacker +{ + internal static void Write(NetDataWriter writer, ColorHSVA data) + { + writer.Put(data.Hue); + writer.Put(data.Saturation); + writer.Put(data.Value); + writer.Put(data.Alpha); + } + + internal static ColorHSVA Read(NetDataReader reader) + { + float hue = reader.GetFloat(); + float saturation = reader.GetFloat(); + float value = reader.GetFloat(); + float alpha = reader.GetFloat(); + + return new ColorHSVA(hue, saturation, value, alpha); + } +} diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Line3DNetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Line3DNetPacker.cs new file mode 100644 index 0000000..1946710 --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Line3DNetPacker.cs @@ -0,0 +1,22 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class Line3DNetPacker +{ + internal static void Write(NetDataWriter writer, Line3D data) + { + Vector3DNetPacker.Write(writer, data.From); + Vector3DNetPacker.Write(writer, data.To); + } + + internal static Line3D Read(NetDataReader reader) + { + Vector3D from = Vector3DNetPacker.Read(reader); + Vector3D to = Vector3DNetPacker.Read(reader); + + return new Line3D(from, to); + } +} diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray2DNetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray2DNetPacker.cs new file mode 100644 index 0000000..c1782fc --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray2DNetPacker.cs @@ -0,0 +1,22 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class Ray2DNetPacker +{ + internal static void Write(NetDataWriter writer, Ray2D data) + { + Vector2DNetPacker.Write(writer, data.Origin); + Vector2DNetPacker.Write(writer, data.Direction); + } + + internal static Ray2D Read(NetDataReader reader) + { + Vector2D from = Vector2DNetPacker.Read(reader); + Vector2D direction = Vector2DNetPacker.Read(reader); + + return new Ray2D(from, direction); + } +} diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray3DNetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray3DNetPacker.cs new file mode 100644 index 0000000..2ef8631 --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Ray3DNetPacker.cs @@ -0,0 +1,22 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class Ray3DNetPacker +{ + internal static void Write(NetDataWriter writer, Ray3D data) + { + Vector3DNetPacker.Write(writer, data.Origin); + Vector3DNetPacker.Write(writer, data.Direction); + } + + internal static Ray3D Read(NetDataReader reader) + { + Vector3D from = Vector3DNetPacker.Read(reader); + Vector3D direction = Vector3DNetPacker.Read(reader); + + return new Ray3D(from, direction); + } +} diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector2DIntNetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector2DIntNetPacker.cs new file mode 100644 index 0000000..0f8eb6d --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector2DIntNetPacker.cs @@ -0,0 +1,22 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class Vector2DIntNetPacker +{ + internal static void Write(NetDataWriter writer, Vector2DInt data) + { + writer.Put(data.X); + writer.Put(data.Y); + } + + internal static Vector2DInt Read(NetDataReader reader) + { + int x = reader.GetInt(); + int y = reader.GetInt(); + + return new Vector2DInt(x, y); + } +} diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector3DIntNetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector3DIntNetPacker.cs new file mode 100644 index 0000000..f396478 --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector3DIntNetPacker.cs @@ -0,0 +1,24 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class Vector3DIntNetPacker +{ + internal static void Write(NetDataWriter writer, Vector3DInt data) + { + writer.Put(data.X); + writer.Put(data.Y); + writer.Put(data.Z); + } + + internal static Vector3DInt Read(NetDataReader reader) + { + int x = reader.GetInt(); + int y = reader.GetInt(); + int z = reader.GetInt(); + + return new Vector3DInt(x, y, z); + } +} diff --git a/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector4DNetPacker.cs b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector4DNetPacker.cs new file mode 100644 index 0000000..c088792 --- /dev/null +++ b/Engine.Integration/Engine.Integration.LiteNetLib/Packers/Vector4DNetPacker.cs @@ -0,0 +1,26 @@ +using LiteNetLib.Utils; + +using Engine.Core; + +namespace Engine.Systems.Network; + +internal static class Vector4DNetPacker +{ + internal static void Write(NetDataWriter writer, Vector4D data) + { + writer.Put(data.X); + writer.Put(data.Y); + writer.Put(data.Z); + writer.Put(data.W); + } + + internal static Vector4D Read(NetDataReader reader) + { + float x = reader.GetFloat(); + float y = reader.GetFloat(); + float z = reader.GetFloat(); + float w = reader.GetFloat(); + + return new Vector4D(x, y, z, w); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/ColorHSVAConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/ColorHSVAConverter.cs new file mode 100644 index 0000000..42aff81 --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/ColorHSVAConverter.cs @@ -0,0 +1,28 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class ColorHSVAConverter : EngineTypeYamlSerializerBase +{ + private static readonly int SUBSTRING_START_LENGTH = nameof(ColorHSVA).Length + 1; + + public override ColorHSVA Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + string value = parser.Consume().Value; + string insideParenthesis = value[SUBSTRING_START_LENGTH..^1]; + string[] values = insideParenthesis.Split(", "); + return new ColorHSVA(float.Parse(values[0]), float.Parse(values[1]), float.Parse(values[2]), float.Parse(values[3])); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + ColorHSVA hsva = (ColorHSVA)value!; + emitter.Emit(new Scalar($"{nameof(ColorHSVA)}({hsva.Hue}, {hsva.Saturation}, {hsva.Value}, {hsva.Alpha})")); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Line3DConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Line3DConverter.cs new file mode 100644 index 0000000..a49fd16 --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Line3DConverter.cs @@ -0,0 +1,41 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class Line3DConverter : EngineTypeYamlSerializerBase +{ + public override Line3D Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + parser.Consume(); + + if (parser.Consume().Value.CompareTo(nameof(Line3D.From)) != 0) + throw new ArgumentException($"{nameof(Line3D)} mapping must start with {nameof(Line3D.From)}"); + Vector3D from = (Vector3D)rootDeserializer(typeof(Vector3D))!; + + if (parser.Consume().Value.CompareTo(nameof(Line3D.To)) != 0) + throw new ArgumentException($"{nameof(Line3D)} mapping must end with {nameof(Line3D.To)}"); + Vector3D to = (Vector3D)rootDeserializer(typeof(Vector3D))!; + + parser.Consume(); + + return new Line3D(from, to); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + Line3D line3D = (Line3D)value!; + + emitter.Emit(new MappingStart()); + emitter.Emit(new Scalar(nameof(Line3D.From))); + serializer(line3D.From, typeof(Vector3D)); + emitter.Emit(new Scalar(nameof(Line3D.To))); + serializer(line3D.To, typeof(Vector3D)); + emitter.Emit(new MappingEnd()); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray2DConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray2DConverter.cs new file mode 100644 index 0000000..300b00d --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray2DConverter.cs @@ -0,0 +1,41 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class Ray2DConverter : EngineTypeYamlSerializerBase +{ + public override Ray2D Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + parser.Consume(); + + if (parser.Consume().Value.CompareTo(nameof(Ray2D.Origin)) != 0) + throw new ArgumentException($"{nameof(Ray2D)} mapping must start with {nameof(Ray2D.Origin)}"); + Vector2D origin = (Vector2D)rootDeserializer(typeof(Vector2D))!; + + if (parser.Consume().Value.CompareTo(nameof(Ray2D.Direction)) != 0) + throw new ArgumentException($"{nameof(Ray2D)} mapping must end with {nameof(Ray2D.Direction)}"); + Vector2D direction = (Vector2D)rootDeserializer(typeof(Vector2D))!; + + parser.Consume(); + + return new Ray2D(origin, direction); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + Ray2D ray2D = (Ray2D)value!; + + emitter.Emit(new MappingStart()); + emitter.Emit(new Scalar(nameof(ray2D.Origin))); + serializer(ray2D.Origin, typeof(Vector2D)); + emitter.Emit(new Scalar(nameof(ray2D.Direction))); + serializer(ray2D.Direction, typeof(Vector2D)); + emitter.Emit(new MappingEnd()); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray3DConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray3DConverter.cs new file mode 100644 index 0000000..0120690 --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Ray3DConverter.cs @@ -0,0 +1,41 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class Ray3DConverter : EngineTypeYamlSerializerBase +{ + public override Ray3D Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + parser.Consume(); + + if (parser.Consume().Value.CompareTo(nameof(Ray3D.Origin)) != 0) + throw new ArgumentException($"{nameof(Ray3D)} mapping must start with {nameof(Ray3D.Origin)}"); + Vector3D origin = (Vector3D)rootDeserializer(typeof(Vector3D))!; + + if (parser.Consume().Value.CompareTo(nameof(Ray3D.Direction)) != 0) + throw new ArgumentException($"{nameof(Ray3D)} mapping must end with {nameof(Ray3D.Direction)}"); + Vector3D direction = (Vector3D)rootDeserializer(typeof(Vector3D))!; + + parser.Consume(); + + return new Ray3D(origin, direction); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + Ray3D ray3D = (Ray3D)value!; + + emitter.Emit(new MappingStart()); + emitter.Emit(new Scalar(nameof(ray3D.Origin))); + serializer(ray3D.Origin, typeof(Vector3D)); + emitter.Emit(new Scalar(nameof(ray3D.Direction))); + serializer(ray3D.Direction, typeof(Vector3D)); + emitter.Emit(new MappingEnd()); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector2DIntConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector2DIntConverter.cs new file mode 100644 index 0000000..8b0eea3 --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector2DIntConverter.cs @@ -0,0 +1,28 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class Vector2DIntConverter : EngineTypeYamlSerializerBase +{ + private static readonly int SUBSTRING_START_LENGTH = nameof(Vector2DInt).Length + 1; + + public override Vector2DInt Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + string value = parser.Consume().Value; + string insideParenthesis = value[SUBSTRING_START_LENGTH..^1]; + string[] values = insideParenthesis.Split(", "); + return new Vector2DInt(int.Parse(values[0]), int.Parse(values[1])); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + Vector2DInt vector2DInt = (Vector2DInt)value!; + emitter.Emit(new Scalar($"{nameof(Vector2DInt)}({vector2DInt.X}, {vector2DInt.Y})")); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector3DIntConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector3DIntConverter.cs new file mode 100644 index 0000000..d1adf01 --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector3DIntConverter.cs @@ -0,0 +1,28 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class Vector3DIntConverter : EngineTypeYamlSerializerBase +{ + private static readonly int SUBSTRING_START_LENGTH = nameof(Vector3DInt).Length + 1; + + public override Vector3DInt Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + string value = parser.Consume().Value; + string insideParenthesis = value[SUBSTRING_START_LENGTH..^1]; + string[] values = insideParenthesis.Split(", "); + return new Vector3DInt(int.Parse(values[0]), int.Parse(values[1]), int.Parse(values[2])); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + Vector3DInt vector3DInt = (Vector3DInt)value!; + emitter.Emit(new Scalar($"{nameof(Vector3DInt)}({vector3DInt.X}, {vector3DInt.Y}, {vector3DInt.Z})")); + } +} diff --git a/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector4DConverter.cs b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector4DConverter.cs new file mode 100644 index 0000000..5249c10 --- /dev/null +++ b/Engine.Integration/Engine.Integration.Yaml/Converters/Primitives/Vector4DConverter.cs @@ -0,0 +1,28 @@ +using System; + +using Engine.Core; + +using YamlDotNet.Core; +using YamlDotNet.Core.Events; +using YamlDotNet.Serialization; + +namespace Engine.Serializers.Yaml; + +public class Vector4DConverter : EngineTypeYamlSerializerBase +{ + private static readonly int SUBSTRING_START_LENGTH = nameof(Vector4D).Length + 1; + + public override Vector4D Read(IParser parser, Type type, ObjectDeserializer rootDeserializer) + { + string value = parser.Consume().Value; + string insideParenthesis = value[SUBSTRING_START_LENGTH..^1]; + string[] values = insideParenthesis.Split(", "); + return new Vector4D(float.Parse(values[0]), float.Parse(values[1]), float.Parse(values[2]), float.Parse(values[3])); + } + + public override void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer) + { + Vector4D vector4D = (Vector4D)value!; + emitter.Emit(new Scalar($"{nameof(Vector4D)}({vector4D.X}, {vector4D.Y}, {vector4D.Z}, {vector4D.W})")); + } +} diff --git a/Engine.Systems/Tween/EngineExtensions/TweenLine3DExtensions.cs b/Engine.Systems/Tween/EngineExtensions/TweenLine3DExtensions.cs new file mode 100644 index 0000000..f48c495 --- /dev/null +++ b/Engine.Systems/Tween/EngineExtensions/TweenLine3DExtensions.cs @@ -0,0 +1,31 @@ +using Engine.Core; + +namespace Engine.Systems.Tween; + +public static class TweenLine3DExtensions +{ + private static readonly BoxedPool boxedLine3DPool = new(2); + + public static ITween TweenLine3D(this Line3D initialLine3D, ITweenManager tweenManager, float duration, Line3D targetLine3D, System.Action setMethod) + { + Boxed boxedInitial = boxedLine3DPool.Get(initialLine3D); + Boxed boxedTarget = boxedLine3DPool.Get(targetLine3D); + + ITween tween = tweenManager.StartTween(duration, + t => setMethod?.Invoke( + new Line3D( + boxedInitial.Value.From.Lerp(boxedTarget.Value.From, t), + boxedInitial.Value.To.Lerp(boxedTarget.Value.To, t) + ) + ) + ); + + tween.OnComplete(() => + { + boxedLine3DPool.Return(boxedInitial); + boxedLine3DPool.Return(boxedTarget); + }); + + return tween; + } +} diff --git a/Engine.Systems/Tween/EngineExtensions/TweenRay2DExtensions.cs b/Engine.Systems/Tween/EngineExtensions/TweenRay2DExtensions.cs new file mode 100644 index 0000000..f44fc4b --- /dev/null +++ b/Engine.Systems/Tween/EngineExtensions/TweenRay2DExtensions.cs @@ -0,0 +1,31 @@ +using Engine.Core; + +namespace Engine.Systems.Tween; + +public static class TweenRay2DExtensions +{ + private static readonly BoxedPool boxedRay2DPool = new(2); + + public static ITween TweenRay2D(this Ray2D initialRay2D, ITweenManager tweenManager, float duration, Ray2D targetRay2D, System.Action setMethod) + { + Boxed boxedInitial = boxedRay2DPool.Get(initialRay2D); + Boxed boxedTarget = boxedRay2DPool.Get(targetRay2D); + + ITween tween = tweenManager.StartTween(duration, + t => setMethod?.Invoke( + new Ray2D( + boxedInitial.Value.Origin.Lerp(boxedTarget.Value.Origin, t), + boxedInitial.Value.Direction.Lerp(boxedTarget.Value.Direction, t).Normalized + ) + ) + ); + + tween.OnComplete(() => + { + boxedRay2DPool.Return(boxedInitial); + boxedRay2DPool.Return(boxedTarget); + }); + + return tween; + } +} diff --git a/Engine.Systems/Tween/EngineExtensions/TweenRay3DExtensions.cs b/Engine.Systems/Tween/EngineExtensions/TweenRay3DExtensions.cs new file mode 100644 index 0000000..46c2345 --- /dev/null +++ b/Engine.Systems/Tween/EngineExtensions/TweenRay3DExtensions.cs @@ -0,0 +1,31 @@ +using Engine.Core; + +namespace Engine.Systems.Tween; + +public static class TweenRay3DExtensions +{ + private static readonly BoxedPool boxedRay3DPool = new(2); + + public static ITween TweenRay3D(this Ray3D initialRay3D, ITweenManager tweenManager, float duration, Ray3D targetRay3D, System.Action setMethod) + { + Boxed boxedInitial = boxedRay3DPool.Get(initialRay3D); + Boxed boxedTarget = boxedRay3DPool.Get(targetRay3D); + + ITween tween = tweenManager.StartTween(duration, + t => setMethod?.Invoke( + new Ray3D( + boxedInitial.Value.Origin.Lerp(boxedTarget.Value.Origin, t), + boxedInitial.Value.Direction.Lerp(boxedTarget.Value.Direction, t).Normalized + ) + ) + ); + + tween.OnComplete(() => + { + boxedRay3DPool.Return(boxedInitial); + boxedRay3DPool.Return(boxedTarget); + }); + + return tween; + } +} diff --git a/Engine.Systems/Tween/EngineExtensions/TweenVector4DExtensions.cs b/Engine.Systems/Tween/EngineExtensions/TweenVector4DExtensions.cs new file mode 100644 index 0000000..a90e47c --- /dev/null +++ b/Engine.Systems/Tween/EngineExtensions/TweenVector4DExtensions.cs @@ -0,0 +1,24 @@ +using Engine.Core; + +namespace Engine.Systems.Tween; + +public static class TweenVector4DExtensions +{ + private static readonly BoxedPool boxedVector4DPool = new(2); + + public static ITween TweenVector4D(this Vector4D initialVector4D, ITweenManager tweenManager, float duration, Vector4D targetVector4D, System.Action setMethod) + { + Boxed boxedInitial = boxedVector4DPool.Get(initialVector4D); + Boxed boxedTarget = boxedVector4DPool.Get(targetVector4D); + + ITween tween = tweenManager.StartTween(duration, t => setMethod?.Invoke(boxedInitial.Value.Lerp(boxedTarget.Value, t))); + + tween.OnComplete(() => + { + boxedVector4DPool.Return(boxedInitial); + boxedVector4DPool.Return(boxedTarget); + }); + + return tween; + } +}