From 42993f1a0bb79e03466903630904df83125a2d52 Mon Sep 17 00:00:00 2001 From: Ellpeck Date: Mon, 6 Jun 2022 23:50:13 +0200 Subject: [PATCH] Added LayerPositionF to MLEM.Extended --- CHANGELOG.md | 7 ++ MLEM.Extended/Tiled/LayerPosition.cs | 12 ++- MLEM.Extended/Tiled/LayerPositionF.cs | 132 ++++++++++++++++++++++++++ 3 files changed, 150 insertions(+), 1 deletion(-) create mode 100644 MLEM.Extended/Tiled/LayerPositionF.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index faa46f1..5d8dcf4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -49,6 +49,13 @@ Removals - Marked old Draw and DrawTransformed overloads as obsolete in favor of SpriteBatchContext ones - Marked Tooltip.Paragraph as obsolete in favor of new Paragraphs collection +### MLEM.Extended +Additions +- Added LayerPositionF + +Improvements +- Allow using a StaticSpriteBatch to render an IndividualTiledMapRenderer + ### MLEM.Data Additions - Added the ability to add padding to RuntimeTexturePacker texture regions diff --git a/MLEM.Extended/Tiled/LayerPosition.cs b/MLEM.Extended/Tiled/LayerPosition.cs index c47cfc0..333ddd9 100644 --- a/MLEM.Extended/Tiled/LayerPosition.cs +++ b/MLEM.Extended/Tiled/LayerPosition.cs @@ -4,7 +4,8 @@ using MonoGame.Extended.Tiled; namespace MLEM.Extended.Tiled { /// - /// A struct that represents a position on a with multiple layers. + /// A struct that represents a position on a with multiple layers, where the and coordinates are 32-bit integer numbers. + /// See for a floating point position. /// [DataContract] public struct LayerPosition : IEquatable { @@ -117,5 +118,14 @@ namespace MLEM.Extended.Tiled { return Add(left, -right); } + /// + /// Implicitly converts a to a . + /// + /// The position to convert. + /// The converted position. + public static implicit operator LayerPositionF(LayerPosition position) { + return new LayerPositionF(position.Layer, position.X, position.Y); + } + } } \ No newline at end of file diff --git a/MLEM.Extended/Tiled/LayerPositionF.cs b/MLEM.Extended/Tiled/LayerPositionF.cs new file mode 100644 index 0000000..a84477e --- /dev/null +++ b/MLEM.Extended/Tiled/LayerPositionF.cs @@ -0,0 +1,132 @@ +using System; +using System.Runtime.Serialization; +using MonoGame.Extended.Tiled; + +namespace MLEM.Extended.Tiled { + /// + /// A struct that represents a position on a with multiple layers, where the and coordinates are 32-bit floating point numbers. + /// See for an integer position. + /// + [DataContract] + public struct LayerPositionF : IEquatable { + + /// + /// The name of the layer that this position is on + /// + [DataMember] + public string Layer; + /// + /// The x coordinate of this position + /// + [DataMember] + public float X; + /// + /// The y coordinate of this position + /// + [DataMember] + public float Y; + + /// + /// Creates a new layer position with the given settings + /// + /// The layer name + /// The x coordinate + /// The y coordinate + public LayerPositionF(string layerName, float x, float y) { + this.Layer = layerName; + this.X = x; + this.Y = y; + } + + /// + public bool Equals(LayerPositionF other) { + return this.Layer == other.Layer && this.X == other.X && this.Y == other.Y; + } + + /// Indicates whether this instance and a specified object are equal. + /// The object to compare with the current instance. + /// true if obj and this instance are the same type and represent the same value; otherwise, false. + public override bool Equals(object obj) { + return obj is LayerPositionF other && this.Equals(other); + } + + /// Returns the hash code for this instance. + /// A 32-bit signed integer that is the hash code for this instance. + public override int GetHashCode() { + var hashCode = this.Layer.GetHashCode(); + hashCode = (hashCode * 397) ^ this.X.GetHashCode(); + hashCode = (hashCode * 397) ^ this.Y.GetHashCode(); + return hashCode; + } + + /// Returns the fully qualified type name of this instance. + /// The fully qualified type name. + public override string ToString() { + return $"{nameof(this.Layer)}: {this.Layer}, {nameof(this.X)}: {this.X}, {nameof(this.Y)}: {this.Y}"; + } + + /// + /// Adds the given layer positions together, returning a new layer position with the sum of their coordinates. + /// If the two layer positions' differ, an is thrown. + /// + /// The left position. + /// The right position. + /// The sum of the positions. + /// Thrown if the two positions' are not the same. + public static LayerPositionF Add(LayerPositionF left, LayerPositionF right) { + if (left.Layer != right.Layer) + throw new ArgumentException("Cannot add layer positions on different layers"); + return new LayerPositionF(left.Layer, left.X + right.X, left.Y + right.Y); + } + + /// + public static bool operator ==(LayerPositionF left, LayerPositionF right) { + return left.Equals(right); + } + + /// + public static bool operator !=(LayerPositionF left, LayerPositionF right) { + return !left.Equals(right); + } + + /// + /// Returns the negative of the given layer position. + /// + /// The position to negate. + /// The negative position. + public static LayerPositionF operator -(LayerPositionF position) { + return new LayerPositionF(position.Layer, -position.X, -position.Y); + } + + /// + /// Returns the sum of the two layer positions using . + /// + /// The left position. + /// The right position. + /// The sum of the positions. + public static LayerPositionF operator +(LayerPositionF left, LayerPositionF right) { + return Add(left, right); + } + + /// + /// Subtracts the second from the first position using . + /// + /// The left position. + /// The right position. + /// The difference of the positions. + public static LayerPositionF operator -(LayerPositionF left, LayerPositionF right) { + return Add(left, -right); + } + + /// + /// Implicitly converts a to a . + /// The coordinates are typecast to 32-bit integers in the process. + /// + /// The position to convert. + /// The converted position. + public static implicit operator LayerPosition(LayerPositionF position) { + return new LayerPosition(position.Layer, (int) position.X, (int) position.Y); + } + + } +} \ No newline at end of file