public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
- public Matrix3 SpaceMatrix;
+ public Matrix3x2 SpaceMatrix;
public MapId Map;
private readonly Font _font;
if (SpaceTiles == null)
return;
- gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds);
+ Matrix3x2.Invert(SpaceMatrix, out var invSpace);
+ gridBounds = invSpace.TransformBox(args.WorldBounds);
DrawText(handle, gridBounds, SpaceMatrix, SpaceTiles, SpaceTileSize);
}
private void DrawText(
DrawingHandleScreen handle,
Box2 gridBounds,
- Matrix3 transform,
+ Matrix3x2 transform,
Dictionary<int, List<Vector2i>> tileSets,
ushort tileSize)
{
if (!gridBounds.Contains(centre))
continue;
- var worldCenter = transform.Transform(centre);
+ var worldCenter = Vector2.Transform(centre, transform);
var screenCenter = _eyeManager.WorldToScreen(worldCenter);
if (tileSets.TryGetValue(0, out var set))
{
var epicenter = set.First();
- var worldCenter = transform.Transform((epicenter + Vector2Helpers.Half) * tileSize);
+ var worldCenter = Vector2.Transform((epicenter + Vector2Helpers.Half) * tileSize, transform);
var screenCenter = _eyeManager.WorldToScreen(worldCenter) + new Vector2(-24, -24);
var text = $"{Intensity[0]:F2}\nΣ={TotalIntensity:F1}\nΔ={Slope:F1}";
handle.DrawString(_font, screenCenter, text);
if (SpaceTiles == null)
return;
- gridBounds = Matrix3.Invert(SpaceMatrix).TransformBox(args.WorldBounds).Enlarged(2);
+ Matrix3x2.Invert(SpaceMatrix, out var invSpace);
+ gridBounds = invSpace.TransformBox(args.WorldBounds).Enlarged(2);
handle.SetTransform(SpaceMatrix);
DrawTiles(handle, gridBounds, SpaceTiles, SpaceTileSize);
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
}
private void DrawTiles(
DrawData(msg, handle);
}
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
}
private void DrawData(DebugMessage msg,
var (_, _, worldMatrix, invMatrix) = gridXform.GetWorldPositionRotationMatrixWithInv();
state.drawHandle.SetTransform(worldMatrix);
- var floatBounds = invMatrix.TransformBox(in state.WorldBounds).Enlarged(grid.TileSize);
+ var floatBounds = invMatrix.TransformBox(state.WorldBounds).Enlarged(grid.TileSize);
var localBounds = new Box2i(
(int) MathF.Floor(floatBounds.Left),
(int) MathF.Floor(floatBounds.Bottom),
});
drawHandle.UseShader(null);
- drawHandle.SetTransform(Matrix3.Identity);
+ drawHandle.SetTransform(Matrix3x2.Identity);
}
private void DrawMapOverlay(
renderOrder = sprite.RenderOrder;
var (spritePos, spriteRot) = transform.GetWorldPositionRotation(xformQuery);
var spriteBB = sprite.CalculateRotatedBoundingBox(spritePos, spriteRot, eye.Rotation);
- bottom = Matrix3.CreateRotation(eye.Rotation).TransformBox(spriteBB).Bottom;
+ bottom = Matrix3Helpers.CreateRotation(eye.Rotation).TransformBox(spriteBB).Bottom;
- var invSpriteMatrix = Matrix3.Invert(sprite.GetLocalMatrix());
+ Matrix3x2.Invert(sprite.GetLocalMatrix(), out var invSpriteMatrix);
// This should have been the rotation of the sprite relative to the screen, but this is not the case with no-rot or directional sprites.
var relativeRotation = (spriteRot + eye.Rotation).Reduced().FlipPositive();
Angle cardinalSnapping = sprite.SnapCardinals ? relativeRotation.GetCardinalDir().ToAngle() : Angle.Zero;
// First we get `localPos`, the clicked location in the sprite-coordinate frame.
- var entityXform = Matrix3.CreateInverseTransform(transform.WorldPosition, sprite.NoRotation ? -eye.Rotation : spriteRot - cardinalSnapping);
- var localPos = invSpriteMatrix.Transform(entityXform.Transform(worldPos));
+ var entityXform = Matrix3Helpers.CreateInverseTransform(transform.WorldPosition, sprite.NoRotation ? -eye.Rotation : spriteRot - cardinalSnapping);
+ var localPos = Vector2.Transform(Vector2.Transform(worldPos, entityXform), invSpriteMatrix);
// Check explicitly defined click-able bounds
if (CheckDirBound(sprite, relativeRotation, localPos))
// convert to layer-local coordinates
layer.GetLayerDrawMatrix(dir, out var matrix);
- var inverseMatrix = Matrix3.Invert(matrix);
- var layerLocal = inverseMatrix.Transform(localPos);
+ Matrix3x2.Invert(matrix, out var inverseMatrix);
+ var layerLocal = Vector2.Transform(localPos, inverseMatrix);
// Convert to image coordinates
var layerImagePos = (Vector2i) (layerLocal * EyeManager.PixelsPerMeter * new Vector2(1, -1) + rsiState.Size / 2f);
+using System.Numerics;
using Content.Shared.Decals;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
handle.DrawTexture(cache.Texture, decal.Coordinates, angle, decal.Color);
}
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
}
}
}
var handle = args.WorldHandle;
handle.SetTransform(worldMatrix);
- var localPos = invMatrix.Transform(mousePos.Position);
+ var localPos = Vector2.Transform(mousePos.Position, invMatrix);
if (snap)
{
var box = new Box2Rotated(aabb, rotation, localPos);
handle.DrawTextureRect(_sprite.Frame0(decal.Sprite), box, color);
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
}
}
// If you use the display UI scale then need to set max(1f, displayscale) because 0 is valid.
const float scale = 1f;
- var scaleMatrix = Matrix3.CreateScale(new Vector2(scale, scale));
- var rotationMatrix = Matrix3.CreateRotation(-rotation);
+ var scaleMatrix = Matrix3Helpers.CreateScale(new Vector2(scale, scale));
+ var rotationMatrix = Matrix3Helpers.CreateRotation(-rotation);
var curTime = _timing.CurTime;
? curTime - _meta.GetPauseTime(uid, meta)
: curTime;
- var worldMatrix = Matrix3.CreateTranslation(worldPosition);
- Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
- Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
+ var worldMatrix = Matrix3Helpers.CreateTranslation(worldPosition);
+ var scaledWorld = Matrix3x2.Multiply(scaleMatrix, worldMatrix);
+ var matty = Matrix3x2.Multiply(rotationMatrix, scaledWorld);
handle.SetTransform(matty);
var offset = 0f;
}
handle.UseShader(null);
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
}
public Color GetProgressColor(float progress, float alpha = 1f)
DrawExplosion(drawHandle, args.WorldBounds, visuals, index, xforms, textures);
}
- drawHandle.SetTransform(Matrix3.Identity);
+ drawHandle.SetTransform(Matrix3x2.Identity);
drawHandle.UseShader(null);
}
if (visuals.SpaceTiles == null)
return;
- gridBounds = Matrix3.Invert(visuals.SpaceMatrix).TransformBox(worldBounds).Enlarged(2);
+ Matrix3x2.Invert(visuals.SpaceMatrix, out var invSpace);
+ gridBounds = invSpace.TransformBox(worldBounds).Enlarged(2);
drawHandle.SetTransform(visuals.SpaceMatrix);
DrawTiles(drawHandle, gridBounds, index, visuals.SpaceTiles, visuals, visuals.SpaceTileSize, textures);
-using Content.Shared.FixedPoint;
+using System.Numerics;
+using Content.Shared.FixedPoint;
using Robust.Client.Graphics;
using Robust.Client.ResourceManagement;
using Robust.Shared.Enums;
}
}
- drawHandle.SetTransform(Matrix3.Identity);
+ drawHandle.SetTransform(Matrix3x2.Identity);
}
private void DrawScreen(in OverlayDrawArgs args)
if (!gridBounds.Contains(centre))
continue;
- var screenCenter = _eyeManager.WorldToScreen(matrix.Transform(centre));
+ var screenCenter = _eyeManager.WorldToScreen(Vector2.Transform(centre, matrix));
drawHandle.DrawString(_font, screenCenter, debugOverlayData.CurrentVolume.ToString(), Color.White);
}
if (!_mapManager.TryFindGridAt(mousePos, out var gridUid, out var grid))
return;
- StartDragging(gridUid, Transform(gridUid).InvWorldMatrix.Transform(mousePos.Position));
+ StartDragging(gridUid, Vector2.Transform(mousePos.Position, Transform(gridUid).InvWorldMatrix));
}
if (!TryComp(_dragging, out TransformComponent? xform))
return;
}
- var localToWorld = xform.WorldMatrix.Transform(_localPosition);
+ var localToWorld = Vector2.Transform(_localPosition, xform.WorldMatrix);
if (localToWorld.EqualsApprox(mousePos.Position, 0.01f)) return;
foreach (var crumb in chunk.Value)
{
- var crumbMapPos = worldMatrix.Transform(_system.GetCoordinate(chunk.Key, crumb.Coordinates));
+ var crumbMapPos = Vector2.Transform(_system.GetCoordinate(chunk.Key, crumb.Coordinates), worldMatrix);
var distance = (crumbMapPos - mouseWorldPos.Position).Length();
if (distance < nearestDistance)
foreach (var poly in tile)
{
- if (poly.Box.Contains(invGridMatrix.Transform(mouseWorldPos.Position)))
+ if (poly.Box.Contains(Vector2.Transform(mouseWorldPos.Position, invGridMatrix)))
{
nearest = poly;
break;
if (neighborMap.MapId != args.MapId)
continue;
- neighborPos = invMatrix.Transform(neighborMap.Position);
+ neighborPos = Vector2.Transform(neighborMap.Position, invMatrix);
}
else
{
}
}
- worldHandle.SetTransform(Matrix3.Identity);
+ worldHandle.SetTransform(Matrix3x2.Identity);
}
}
}
}
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
_gridIndex.Clear();
}
var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
const float scale = 1f;
- var scaleMatrix = Matrix3.CreateScale(new Vector2(scale, scale));
- var rotationMatrix = Matrix3.CreateRotation(-rotation);
+ var scaleMatrix = Matrix3Helpers.CreateScale(new Vector2(scale, scale));
+ var rotationMatrix = Matrix3Helpers.CreateRotation(-rotation);
var query = _entManager.AllEntityQueryEnumerator<MobThresholdsComponent, MobStateComponent, DamageableComponent, SpriteComponent>();
while (query.MoveNext(out var uid,
continue;
var worldPosition = _transform.GetWorldPosition(xform);
- var worldMatrix = Matrix3.CreateTranslation(worldPosition);
+ var worldMatrix = Matrix3Helpers.CreateTranslation(worldPosition);
- Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
- Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
+ var scaledWorld = Matrix3x2.Multiply(scaleMatrix, worldMatrix);
+ var matty = Matrix3x2.Multiply(rotationMatrix, scaledWorld);
handle.SetTransform(matty);
handle.DrawRect(pixelDarken, Black.WithAlpha(128));
}
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
}
/// <summary>
public sealed partial class StencilOverlay
{
- private void DrawRestrictedRange(in OverlayDrawArgs args, RestrictedRangeComponent rangeComp, Matrix3 invMatrix)
+ private void DrawRestrictedRange(in OverlayDrawArgs args, RestrictedRangeComponent rangeComp, Matrix3x2 invMatrix)
{
var worldHandle = args.WorldHandle;
var renderScale = args.Viewport.RenderScale.X;
var length = zoom.X;
var bufferRange = MathF.Min(10f, rangeComp.Range);
- var pixelCenter = invMatrix.Transform(rangeComp.Origin);
+ var pixelCenter = Vector2.Transform(rangeComp.Origin, invMatrix);
// Something something offset?
var vertical = args.Viewport.Size.Y;
worldHandle.DrawRect(localAABB, Color.White);
}, Color.Transparent);
- worldHandle.SetTransform(Matrix3.Identity);
+ worldHandle.SetTransform(Matrix3x2.Identity);
worldHandle.UseShader(_protoManager.Index<ShaderPrototype>("StencilMask").Instance());
worldHandle.DrawTextureRect(_blep!.Texture, worldBounds);
var curTime = _timing.RealTime;
{
private List<Entity<MapGridComponent>> _grids = new();
- private void DrawWeather(in OverlayDrawArgs args, WeatherPrototype weatherProto, float alpha, Matrix3 invMatrix)
+ private void DrawWeather(in OverlayDrawArgs args, WeatherPrototype weatherProto, float alpha, Matrix3x2 invMatrix)
{
var worldHandle = args.WorldHandle;
var mapId = args.MapId;
foreach (var grid in _grids)
{
var matrix = _transform.GetWorldMatrix(grid, xformQuery);
- Matrix3.Multiply(in matrix, in invMatrix, out var matty);
+ var matty = Matrix3x2.Multiply(matrix, invMatrix);
worldHandle.SetTransform(matty);
foreach (var tile in grid.Comp.GetTilesIntersecting(worldAABB))
}, Color.Transparent);
- worldHandle.SetTransform(Matrix3.Identity);
+ worldHandle.SetTransform(Matrix3x2.Identity);
worldHandle.UseShader(_protoManager.Index<ShaderPrototype>("StencilMask").Instance());
worldHandle.DrawTextureRect(_blep!.Texture, worldBounds);
var curTime = _timing.RealTime;
worldHandle.UseShader(_protoManager.Index<ShaderPrototype>("StencilDraw").Instance());
_parallax.DrawParallax(worldHandle, worldAABB, sprite, curTime, position, Vector2.Zero, modulate: (weatherProto.Color ?? Color.White).WithAlpha(alpha));
- worldHandle.SetTransform(Matrix3.Identity);
+ worldHandle.SetTransform(Matrix3x2.Identity);
worldHandle.UseShader(null);
}
}
+using System.Numerics;
using Content.Client.Parallax;
using Content.Client.Weather;
using Content.Shared.Salvage;
}
args.WorldHandle.UseShader(null);
- args.WorldHandle.SetTransform(Matrix3.Identity);
+ args.WorldHandle.SetTransform(Matrix3x2.Identity);
}
}
base.Draw(handle);
// Restore a sane transform+shader
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
handle.UseShader(null);
}
}
base.Draw(handle);
// Restore a sane transform+shader
- handle.SetTransform(Matrix3.Identity);
+ handle.SetTransform(Matrix3x2.Identity);
handle.UseShader(null);
}
}
// Convert to a world position
var unscaledPosition = (localPosition - MidPointVector) / MinimapScale;
- var worldPosition = _transformSystem.GetWorldMatrix(_xform).Transform(new Vector2(unscaledPosition.X, -unscaledPosition.Y) + offset);
+ var worldPosition = Vector2.Transform(new Vector2(unscaledPosition.X, -unscaledPosition.Y) + offset, _transformSystem.GetWorldMatrix(_xform));
// Find closest tracked entity in range
var closestEntity = NetEntity.Invalid;
if (mapPos.MapId != MapId.Nullspace)
{
- var position = _transformSystem.GetInvWorldMatrix(_xform).Transform(mapPos.Position) - offset;
+ var position = Vector2.Transform(mapPos.Position, _transformSystem.GetInvWorldMatrix(_xform)) - offset;
position = ScalePosition(new Vector2(position.X, -position.Y));
handle.DrawCircle(position, float.Sqrt(MinimapScale) * 2f, value.Color);
if (mapPos.MapId != MapId.Nullspace)
{
- var position = _transformSystem.GetInvWorldMatrix(_xform).Transform(mapPos.Position) - offset;
+ var position = Vector2.Transform(mapPos.Position, _transformSystem.GetInvWorldMatrix(_xform)) - offset;
position = ScalePosition(new Vector2(position.X, -position.Y));
var scalingCoefficient = MinmapScaleModifier * float.Sqrt(MinimapScale);
+using System.Numerics;
using Content.Shared.Examine;
using Robust.Client.Graphics;
using Robust.Client.Player;
if (args.ViewportControl == null)
return;
- args.DrawingHandle.SetTransform(Matrix3.Identity);
+ args.DrawingHandle.SetTransform(Matrix3x2.Identity);
args.DrawingHandle.UseShader(_shader);
var scale = _configManager.GetCVar(CVars.DisplayUIScale);
e => e == popup.InitialPos.EntityId || e == ourEntity, entMan: _entManager))
continue;
- var pos = matrix.Transform(mapPos.Position);
+ var pos = Vector2.Transform(mapPos.Position, matrix);
_controller.DrawPopup(popup, worldHandle, pos, scale);
}
}
+using System.Numerics;
using Content.Shared.Shuttles.Events;
using Content.Shared.Shuttles.Systems;
using Robust.Client.Graphics;
args.WorldHandle.SetTransform(xform.WorldMatrix);
args.WorldHandle.DrawRect(Position.Value, Color.Red.WithAlpha(100));
- args.WorldHandle.SetTransform(Matrix3.Identity);
+ args.WorldHandle.SetTransform(Matrix3x2.Identity);
}
}
+using System.Numerics;
using Content.Client.UserInterface.Controls;
using Content.Shared.Shuttles.Components;
using Robust.Client.AutoGenerated;
}
}
- protected void DrawGrid(DrawingHandleScreen handle, Matrix3 matrix, Entity<MapGridComponent> grid, Color color, float alpha = 0.01f)
+ protected void DrawGrid(DrawingHandleScreen handle, Matrix3x2 matrix, Entity<MapGridComponent> grid, Color color, float alpha = 0.01f)
{
var rator = Maps.GetAllTilesEnumerator(grid.Owner, grid.Comp);
var minimapScale = MinimapScale;
public float MinimapScale;
public Vector2 MidPoint;
- public Matrix3 Matrix;
+ public Matrix3x2 Matrix;
public List<Vector2> Vertices;
public Vector2[] ScaledVertices;
public void Execute(int index)
{
var vert = Vertices[index];
- var adjustedVert = Matrix.Transform(vert);
+ var adjustedVert = Vector2.Transform(vert, Matrix);
adjustedVert = adjustedVert with { Y = -adjustedVert.Y };
var scaledVert = ScalePosition(adjustedVert, MinimapScale, MidPoint);
+using System.Numerics;
using Content.Shared.Shuttles.BUIStates;
using Robust.Client.AutoGenerated;
using Robust.Client.Graphics;
}
var (_, worldRot, worldMatrix) = _xformSystem.GetWorldPositionRotationMatrix(gridXform);
- var worldPos = worldMatrix.Transform(gridBody.LocalCenter);
+ var worldPos = Vector2.Transform(gridBody.LocalCenter, worldMatrix);
// Get the positive reduced angle.
var displayRot = -worldRot.Reduced();
var gridNent = EntManager.GetNetEntity(GridEntity);
var mapPos = _xformSystem.ToMapCoordinates(_coordinates.Value);
var ourGridMatrix = _xformSystem.GetWorldMatrix(gridXform.Owner);
- var dockMatrix = Matrix3.CreateTransform(_coordinates.Value.Position, Angle.Zero);
- Matrix3.Multiply(dockMatrix, ourGridMatrix, out var offsetMatrix);
+ var dockMatrix = Matrix3Helpers.CreateTransform(_coordinates.Value.Position, Angle.Zero);
+ var worldFromDock = Matrix3x2.Multiply(dockMatrix, ourGridMatrix);
- offsetMatrix = offsetMatrix.Invert();
+ Matrix3x2.Invert(worldFromDock, out var offsetMatrix);
// Draw nearby grids
var controlBounds = PixelSizeBox;
continue;
var gridMatrix = _xformSystem.GetWorldMatrix(grid.Owner);
- Matrix3.Multiply(in gridMatrix, in offsetMatrix, out var matty);
+ var matty = Matrix3x2.Multiply(gridMatrix, offsetMatrix);
var color = _shuttles.GetIFFColor(grid.Owner, grid.Owner == GridEntity, component: iffComp);
DrawGrid(handle, matty, grid, color);
if (ViewedDock == dock.Entity)
continue;
- var position = matty.Transform(dock.Coordinates.Position);
+ var position = Vector2.Transform(dock.Coordinates.Position, matty);
- var otherDockRotation = Matrix3.CreateRotation(dock.Angle);
+ var otherDockRotation = Matrix3Helpers.CreateRotation(dock.Angle);
var scaledPos = ScalePosition(position with {Y = -position.Y});
if (!controlBounds.Contains(scaledPos.Floored()))
continue;
// Draw the dock's collision
- var collisionBL = matty.Transform(dock.Coordinates.Position +
- otherDockRotation.Transform(new Vector2(-0.2f, -0.7f)));
- var collisionBR = matty.Transform(dock.Coordinates.Position +
- otherDockRotation.Transform(new Vector2(0.2f, -0.7f)));
- var collisionTR = matty.Transform(dock.Coordinates.Position +
- otherDockRotation.Transform(new Vector2(0.2f, -0.5f)));
- var collisionTL = matty.Transform(dock.Coordinates.Position +
- otherDockRotation.Transform(new Vector2(-0.2f, -0.5f)));
+ var collisionBL = Vector2.Transform(dock.Coordinates.Position +
+ Vector2.Transform(new Vector2(-0.2f, -0.7f), otherDockRotation), matty);
+ var collisionBR = Vector2.Transform(dock.Coordinates.Position +
+ Vector2.Transform(new Vector2(0.2f, -0.7f), otherDockRotation), matty);
+ var collisionTR = Vector2.Transform(dock.Coordinates.Position +
+ Vector2.Transform(new Vector2(0.2f, -0.5f), otherDockRotation), matty);
+ var collisionTL = Vector2.Transform(dock.Coordinates.Position +
+ Vector2.Transform(new Vector2(-0.2f, -0.5f), otherDockRotation), matty);
var verts = new[]
{
handle.DrawPrimitives(DrawPrimitiveTopology.LineList, verts, otherDockConnection);
// Draw the dock itself
- var dockBL = matty.Transform(dock.Coordinates.Position + new Vector2(-0.5f, -0.5f));
- var dockBR = matty.Transform(dock.Coordinates.Position + new Vector2(0.5f, -0.5f));
- var dockTR = matty.Transform(dock.Coordinates.Position + new Vector2(0.5f, 0.5f));
- var dockTL = matty.Transform(dock.Coordinates.Position + new Vector2(-0.5f, 0.5f));
+ var dockBL = Vector2.Transform(dock.Coordinates.Position + new Vector2(-0.5f, -0.5f), matty);
+ var dockBR = Vector2.Transform(dock.Coordinates.Position + new Vector2(0.5f, -0.5f), matty);
+ var dockTR = Vector2.Transform(dock.Coordinates.Position + new Vector2(0.5f, 0.5f), matty);
+ var dockTL = Vector2.Transform(dock.Coordinates.Position + new Vector2(-0.5f, 0.5f), matty);
verts = new[]
{
// Draw the dock's collision
var invertedPosition = Vector2.Zero;
invertedPosition.Y = -invertedPosition.Y;
- var rotation = Matrix3.CreateRotation(-_angle.Value + MathF.PI);
+ var rotation = Matrix3Helpers.CreateRotation(-_angle.Value + MathF.PI);
var ourDockConnection = new UIBox2(
- ScalePosition(rotation.Transform(new Vector2(-0.2f, -0.7f))),
- ScalePosition(rotation.Transform(new Vector2(0.2f, -0.5f))));
+ ScalePosition(Vector2.Transform(new Vector2(-0.2f, -0.7f), rotation)),
+ ScalePosition(Vector2.Transform(new Vector2(0.2f, -0.5f), rotation)));
var ourDock = new UIBox2(
- ScalePosition(rotation.Transform(new Vector2(-0.5f, 0.5f))),
- ScalePosition(rotation.Transform(new Vector2(0.5f, -0.5f))));
+ ScalePosition(Vector2.Transform(new Vector2(-0.5f, 0.5f), rotation)),
+ ScalePosition(Vector2.Transform(new Vector2(0.5f, -0.5f), rotation)));
var dockColor = Color.Magenta;
var connectionColor = Color.Pink;
var beaconsOnly = EntManager.TryGetComponent(mapUid, out FTLDestinationComponent? destComp) &&
destComp.BeaconsOnly;
- var mapTransform = Matrix3.CreateInverseTransform(Offset, Angle.Zero);
+ var mapTransform = Matrix3Helpers.CreateInverseTransform(Offset, Angle.Zero);
if (beaconsOnly && TryGetBeacon(_beacons, mapTransform, args.RelativePixelPosition, PixelRect, out var foundBeacon, out _))
{
/// </summary>
/// <param name="mapObjects"></param>
/// <returns></returns>
- private List<IMapObject> GetViewportMapObjects(Matrix3 matty, List<IMapObject> mapObjects)
+ private List<IMapObject> GetViewportMapObjects(Matrix3x2 matty, List<IMapObject> mapObjects)
{
var results = new List<IMapObject>();
var enlargement = new Vector2i((int) (16 * UIScale), (int) (16 * UIScale));
var mapCoords = _shuttles.GetMapCoordinates(mapObj);
- var relativePos = matty.Transform(mapCoords.Position);
+ var relativePos = Vector2.Transform(mapCoords.Position, matty);
relativePos = relativePos with { Y = -relativePos.Y };
var uiPosition = ScalePosition(relativePos);
DrawParallax(handle);
var viewedMapUid = _mapManager.GetMapEntityId(ViewingMap);
- var matty = Matrix3.CreateInverseTransform(Offset, Angle.Zero);
+ var matty = Matrix3Helpers.CreateInverseTransform(Offset, Angle.Zero);
var realTime = _timing.RealTime;
var viewBox = new Box2(Offset - WorldRangeVector, Offset + WorldRangeVector);
var viewportObjects = GetViewportMapObjects(matty, mapObjects);
var (gridPos, gridRot) = _xformSystem.GetWorldPositionRotation(shuttleXform);
gridPos = Maps.GetGridPosition((gridUid, gridPhysics), gridPos, gridRot);
- var gridRelativePos = matty.Transform(gridPos);
+ var gridRelativePos = Vector2.Transform(gridPos, matty);
gridRelativePos = gridRelativePos with { Y = -gridRelativePos.Y };
var gridUiPos = ScalePosition(gridRelativePos);
continue;
}
- var adjustedPos = matty.Transform(mapCoords.Position);
+ var adjustedPos = Vector2.Transform(mapCoords.Position, matty);
var localPos = ScalePosition(adjustedPos with { Y = -adjustedPos.Y});
handle.DrawCircle(localPos, exclusion.Range * MinimapScale, exclusionColor.WithAlpha(0.05f));
handle.DrawCircle(localPos, exclusion.Range * MinimapScale, exclusionColor, filled: false);
foreach (var (beaconName, coords, mapO) in GetBeacons(viewportObjects, matty, controlLocalBounds))
{
- var localPos = matty.Transform(coords.Position);
+ var localPos = Vector2.Transform(coords.Position, matty);
localPos = localPos with { Y = -localPos.Y };
var beaconUiPos = ScalePosition(localPos);
var mapObject = GetMapObject(localPos, Angle.Zero, scale: 0.75f, scalePosition: true);
var (gridPos, gridRot) = _xformSystem.GetWorldPositionRotation(grid.Owner);
gridPos = Maps.GetGridPosition((grid, gridPhysics), gridPos, gridRot);
- var gridRelativePos = matty.Transform(gridPos);
+ var gridRelativePos = Vector2.Transform(gridPos, matty);
gridRelativePos = gridRelativePos with { Y = -gridRelativePos.Y };
var gridUiPos = ScalePosition(gridRelativePos);
var color = ftlFree ? Color.LimeGreen : Color.Magenta;
- var gridRelativePos = matty.Transform(gridPos);
+ var gridRelativePos = Vector2.Transform(gridPos, matty);
gridRelativePos = gridRelativePos with { Y = -gridRelativePos.Y };
var gridUiPos = ScalePosition(gridRelativePos);
/// <summary>
/// Returns the beacons that intersect the viewport.
/// </summary>
- private IEnumerable<(string Beacon, MapCoordinates Coordinates, IMapObject MapObject)> GetBeacons(List<IMapObject> mapObjs, Matrix3 mapTransform, UIBox2i area)
+ private IEnumerable<(string Beacon, MapCoordinates Coordinates, IMapObject MapObject)> GetBeacons(List<IMapObject> mapObjs, Matrix3x2 mapTransform, UIBox2i area)
{
foreach (var mapO in mapObjs)
{
continue;
var beaconCoords = EntManager.GetCoordinates(beacon.Coordinates).ToMap(EntManager, _xformSystem);
- var position = mapTransform.Transform(beaconCoords.Position);
+ var position = Vector2.Transform(beaconCoords.Position, mapTransform);
var localPos = ScalePosition(position with {Y = -position.Y});
// If beacon not on screen then ignore it.
return mapObj;
}
- private bool TryGetBeacon(IEnumerable<IMapObject> mapObjects, Matrix3 mapTransform, Vector2 mousePos, UIBox2i area, out ShuttleBeaconObject foundBeacon, out Vector2 foundLocalPos)
+ private bool TryGetBeacon(IEnumerable<IMapObject> mapObjects, Matrix3x2 mapTransform, Vector2 mousePos, UIBox2i area, out ShuttleBeaconObject foundBeacon, out Vector2 foundLocalPos)
{
// In pixels
const float BeaconSnapRange = 32f;
if (!_shuttles.CanFTLBeacon(beaconObj.Coordinates))
continue;
- var position = mapTransform.Transform(beaconCoords.Position);
+ var position = Vector2.Transform(beaconCoords.Position, mapTransform);
var localPos = ScalePosition(position with {Y = -position.Y});
// If beacon not on screen then ignore it.
var mapPos = _transform.ToMapCoordinates(_coordinates.Value);
var offset = _coordinates.Value.Position;
- var posMatrix = Matrix3.CreateTransform(offset, _rotation.Value);
+ var posMatrix = Matrix3Helpers.CreateTransform(offset, _rotation.Value);
var (_, ourEntRot, ourEntMatrix) = _transform.GetWorldPositionRotationMatrix(_coordinates.Value.EntityId);
- Matrix3.Multiply(posMatrix, ourEntMatrix, out var ourWorldMatrix);
- var ourWorldMatrixInvert = ourWorldMatrix.Invert();
+ var ourWorldMatrix = Matrix3x2.Multiply(posMatrix, ourEntMatrix);
+ Matrix3x2.Invert(ourWorldMatrix, out var ourWorldMatrixInvert);
// Draw our grid in detail
var ourGridId = xform.GridUid;
fixturesQuery.HasComponent(ourGridId.Value))
{
var ourGridMatrix = _transform.GetWorldMatrix(ourGridId.Value);
- Matrix3.Multiply(in ourGridMatrix, in ourWorldMatrixInvert, out var matrix);
+ var matrix = Matrix3x2.Multiply(ourGridMatrix, ourWorldMatrixInvert);
var color = _shuttles.GetIFFColor(ourGridId.Value, self: true);
DrawGrid(handle, matrix, (ourGridId.Value, ourGrid), color);
continue;
var gridMatrix = _transform.GetWorldMatrix(gUid);
- Matrix3.Multiply(in gridMatrix, in ourWorldMatrixInvert, out var matty);
+ var matty = Matrix3x2.Multiply(gridMatrix, ourWorldMatrixInvert);
var color = _shuttles.GetIFFColor(grid, self: false, iff);
// Others default:
{
var gridBounds = grid.Comp.LocalAABB;
- var gridCentre = matty.Transform(gridBody.LocalCenter);
+ var gridCentre = Vector2.Transform(gridBody.LocalCenter, matty);
gridCentre.Y = -gridCentre.Y;
var distance = gridCentre.Length();
var labelText = Loc.GetString("shuttle-console-iff-label", ("name", labelName),
}
}
- private void DrawDocks(DrawingHandleScreen handle, EntityUid uid, Matrix3 matrix)
+ private void DrawDocks(DrawingHandleScreen handle, EntityUid uid, Matrix3x2 matrix)
{
if (!ShowDocks)
return;
foreach (var state in docks)
{
var position = state.Coordinates.Position;
- var uiPosition = matrix.Transform(position);
+ var uiPosition = Vector2.Transform(position, matrix);
if (uiPosition.Length() > (WorldRange * 2f) - DockScale)
continue;
var verts = new[]
{
- matrix.Transform(position + new Vector2(-DockScale, -DockScale)),
- matrix.Transform(position + new Vector2(DockScale, -DockScale)),
- matrix.Transform(position + new Vector2(DockScale, DockScale)),
- matrix.Transform(position + new Vector2(-DockScale, DockScale)),
+ Vector2.Transform(position + new Vector2(-DockScale, -DockScale), matrix),
+ Vector2.Transform(position + new Vector2(DockScale, -DockScale), matrix),
+ Vector2.Transform(position + new Vector2(DockScale, DockScale), matrix),
+ Vector2.Transform(position + new Vector2(-DockScale, DockScale), matrix),
};
for (var i = 0; i < verts.Length; i++)
var eyeRot = args.Viewport.Eye?.Rotation ?? default;
var xformQuery = _entity.GetEntityQuery<TransformComponent>();
- var scaleMatrix = Matrix3.CreateScale(new Vector2(1, 1));
- var rotationMatrix = Matrix3.CreateRotation(-eyeRot);
+ var scaleMatrix = Matrix3Helpers.CreateScale(new Vector2(1, 1));
+ var rotationMatrix = Matrix3Helpers.CreateRotation(-eyeRot);
var query = _entity.AllEntityQueryEnumerator<StatusIconComponent, SpriteComponent, TransformComponent, MetaDataComponent>();
while (query.MoveNext(out var uid, out var comp, out var sprite, out var xform, out var meta))
if (icons.Count == 0)
continue;
- var worldMatrix = Matrix3.CreateTranslation(worldPos);
- Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
- Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
+ var worldMatrix = Matrix3Helpers.CreateTranslation(worldPos);
+ var scaledWorld = Matrix3x2.Multiply(scaleMatrix, worldMatrix);
+ var matty = Matrix3x2.Multiply(rotationMatrix, scaledWorld);
handle.SetTransform(matty);
var countL = 0;
-using System.Linq;
+using System.Linq;
+using System.Numerics;
using Content.Client.Animations;
using Content.Shared.Hands;
using Content.Shared.Storage;
}
var finalMapPos = finalCoords.ToMapPos(EntityManager, TransformSystem);
- var finalPos = TransformSystem.GetInvWorldMatrix(initialCoords.EntityId).Transform(finalMapPos);
+ var finalPos = Vector2.Transform(finalMapPos, TransformSystem.GetInvWorldMatrix(initialCoords.EntityId));
_entityPickupAnimation.AnimateEntityPickup(item, initialCoords, finalPos, initialAngle);
}
if (_rotation != null)
{
var offset = (-_rotation.Value).RotateVec(Size * UIScale / 2) - Size * UIScale / 2;
- handle.SetTransform(Matrix3.CreateTransform(GlobalPixelPosition - offset, -_rotation.Value));
+ handle.SetTransform(Matrix3Helpers.CreateTransform(GlobalPixelPosition - offset, -_rotation.Value));
}
base.Draw(handle);
var inversePos = (value - MidPointVector) / MinimapScale;
inversePos = inversePos with { Y = -inversePos.Y };
- inversePos = Matrix3.CreateTransform(Offset, Angle.Zero).Transform(inversePos);
+ inversePos = Vector2.Transform(inversePos, Matrix3Helpers.CreateTransform(Offset, Angle.Zero));
return inversePos;
}
EnsureViewportCreated();
- var matrix = Matrix3.Invert(GetLocalToScreenMatrix());
- coords = matrix.Transform(coords);
+ Matrix3x2.Invert(GetLocalToScreenMatrix(), out var matrix);
+ coords = Vector2.Transform(coords, matrix);
return _viewport!.LocalToWorld(coords);
}
EnsureViewportCreated();
- var matrix = Matrix3.Invert(GetLocalToScreenMatrix());
- coords = matrix.Transform(coords);
+ Matrix3x2.Invert(GetLocalToScreenMatrix(), out var matrix);
+ coords = Vector2.Transform(coords, matrix);
var ev = new PixelToMapEvent(coords, this, _viewport!);
_entityManager.EventBus.RaiseEvent(EventSource.Local, ref ev);
var matrix = GetLocalToScreenMatrix();
- return matrix.Transform(vpLocal);
+ return Vector2.Transform(vpLocal, matrix);
}
- public Matrix3 GetWorldToScreenMatrix()
+ public Matrix3x2 GetWorldToScreenMatrix()
{
EnsureViewportCreated();
return _viewport!.GetWorldToLocalMatrix() * GetLocalToScreenMatrix();
}
- public Matrix3 GetLocalToScreenMatrix()
+ public Matrix3x2 GetLocalToScreenMatrix()
{
EnsureViewportCreated();
if (scaleFactor.X == 0 || scaleFactor.Y == 0)
// Basically a nonsense scenario, at least make sure to return something that can be inverted.
- return Matrix3.Identity;
+ return Matrix3x2.Identity;
- return Matrix3.CreateTransform(GlobalPixelPosition + drawBox.TopLeft, 0, scaleFactor);
+ return Matrix3Helpers.CreateTransform(GlobalPixelPosition + drawBox.TopLeft, 0, scaleFactor);
}
private void EnsureViewportCreated()
case WeaponArcAnimation.None:
var (mapPos, mapRot) = TransformSystem.GetWorldPositionRotation(userXform);
var worldPos = mapPos + (mapRot - userXform.LocalRotation).RotateVec(localPos);
- var newLocalPos = TransformSystem.GetInvWorldMatrix(xform.ParentUid).Transform(worldPos);
+ var newLocalPos = Vector2.Transform(worldPos, TransformSystem.GetInvWorldMatrix(xform.ParentUid));
TransformSystem.SetLocalPositionNoLerp(animationUid, newLocalPos, xform);
if (arcComponent.Fadeout)
_animation.Play(animationUid, GetFadeAnimation(sprite, 0f, 0.15f), FadeAnimationKey);
-using System.Numerics;
+using System.Numerics;
using Content.Client.Resources;
using Robust.Client.Graphics;
using Robust.Client.ResourceManagement;
{
// Scale rendering in this control by UIScale.
var currentTransform = handle.GetTransform();
- handle.SetTransform(Matrix3.CreateScale(new Vector2(UIScale)) * currentTransform);
+ handle.SetTransform(Matrix3Helpers.CreateScale(new Vector2(UIScale)) * currentTransform);
var countPerRow = CountPerRow(Size.X);
public MapGridComponent Grid;
private bool _needToTransform = false;
- private Matrix3 _matrix = Matrix3.Identity;
+ private Matrix3x2 _matrix = Matrix3x2.Identity;
private Vector2 _offset;
// Tiles which neighbor an exploding tile, but have not yet had the explosion spread to them due to an
int typeIndex,
Dictionary<Vector2i, NeighborFlag> edgeTiles,
EntityUid? referenceGrid,
- Matrix3 spaceMatrix,
+ Matrix3x2 spaceMatrix,
Angle spaceAngle)
{
Grid = grid;
var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Grid.Owner);
var size = (float) Grid.TileSize;
- _matrix.R0C2 = size / 2;
- _matrix.R1C2 = size / 2;
- _matrix *= transform.WorldMatrix * Matrix3.Invert(spaceMatrix);
+ _matrix.M31 = size / 2;
+ _matrix.M32 = size / 2;
+ Matrix3x2.Invert(spaceMatrix, out var invSpace);
+ _matrix *= transform.WorldMatrix * invSpace;
var relativeAngle = transform.WorldRotation - spaceAngle;
_offset = relativeAngle.RotateVec(new Vector2(size / 4, size / 4));
}
return;
}
- var center = _matrix.Transform(tile);
+ var center = Vector2.Transform(tile, _matrix);
SpaceJump.Add(new((int) MathF.Floor(center.X + _offset.X), (int) MathF.Floor(center.Y + _offset.Y)));
SpaceJump.Add(new((int) MathF.Floor(center.X - _offset.Y), (int) MathF.Floor(center.Y + _offset.X)));
SpaceJump.Add(new((int) MathF.Floor(center.X - _offset.X), (int) MathF.Floor(center.Y - _offset.Y)));
{
Dictionary<Vector2i, BlockedSpaceTile> transformedEdges = new();
- var targetMatrix = Matrix3.Identity;
+ var targetMatrix = Matrix3x2.Identity;
Angle targetAngle = new();
var tileSize = DefaultTileSize;
var maxDistanceSq = (int) (maxDistance * maxDistance);
tileSize = targetGrid.TileSize;
}
- var offsetMatrix = Matrix3.Identity;
- offsetMatrix.R0C2 = tileSize / 2f;
- offsetMatrix.R1C2 = tileSize / 2f;
+ var offsetMatrix = Matrix3x2.Identity;
+ offsetMatrix.M31 = tileSize / 2f;
+ offsetMatrix.M32 = tileSize / 2f;
// Here we can end up with a triple nested for loop:
// foreach other grid
var xform = xforms.GetComponent(gridToTransform);
var (_, gridWorldRotation, gridWorldMatrix, invGridWorldMatrid) = xform.GetWorldPositionRotationMatrixWithInv(xforms);
- var localEpicentre = (Vector2i) invGridWorldMatrid.Transform(epicentre.Position);
+ var localEpicentre = (Vector2i) Vector2.Transform(epicentre.Position, invGridWorldMatrid);
var matrix = offsetMatrix * gridWorldMatrix * targetMatrix;
var angle = gridWorldRotation - targetAngle;
if (delta.X * delta.X + delta.Y * delta.Y > maxDistanceSq) // no Vector2.Length???
continue;
- var center = matrix.Transform(tile);
+ var center = Vector2.Transform(tile, matrix);
if ((dir & NeighborFlag.Cardinal) == 0)
{
/// Same as <see cref="ExplodeTile"/>, but for SPAAAAAAACE.
/// </summary>
internal void ExplodeSpace(BroadphaseComponent lookup,
- Matrix3 spaceMatrix,
- Matrix3 invSpaceMatrix,
+ Matrix3x2 spaceMatrix,
+ Matrix3x2 invSpaceMatrix,
Vector2i tile,
float throwForce,
DamageSpecifier damage,
}
private static bool SpaceQueryCallback(
- ref (List<(EntityUid, TransformComponent)> List, HashSet<EntityUid> Processed, Matrix3 InvSpaceMatrix, EntityUid LookupOwner, EntityQuery<TransformComponent> XformQuery, Box2 GridBox, SharedTransformSystem System) state,
+ ref (List<(EntityUid, TransformComponent)> List, HashSet<EntityUid> Processed, Matrix3x2 InvSpaceMatrix, EntityUid LookupOwner, EntityQuery<TransformComponent> XformQuery, Box2 GridBox, SharedTransformSystem System) state,
in EntityUid uid)
{
if (state.Processed.Contains(uid))
if (xform.ParentUid == state.LookupOwner)
{
// parented directly to the map, use local position
- if (state.GridBox.Contains(state.InvSpaceMatrix.Transform(xform.LocalPosition)))
+ if (state.GridBox.Contains(Vector2.Transform(xform.LocalPosition, state.InvSpaceMatrix)))
state.List.Add((uid, xform));
return true;
// finally check if it intersects our tile
var wpos = state.System.GetWorldPosition(xform);
- if (state.GridBox.Contains(state.InvSpaceMatrix.Transform(wpos)))
+ if (state.GridBox.Contains(Vector2.Transform(wpos, state.InvSpaceMatrix)))
state.List.Add((uid, xform));
return true;
}
private static bool SpaceQueryCallback(
- ref (List<(EntityUid, TransformComponent)> List, HashSet<EntityUid> Processed, Matrix3 InvSpaceMatrix, EntityUid LookupOwner, EntityQuery<TransformComponent> XformQuery, Box2 GridBox, SharedTransformSystem System) state,
+ ref (List<(EntityUid, TransformComponent)> List, HashSet<EntityUid> Processed, Matrix3x2 InvSpaceMatrix, EntityUid LookupOwner, EntityQuery<TransformComponent> XformQuery, Box2 GridBox, SharedTransformSystem System) state,
in FixtureProxy proxy)
{
var uid = proxy.Entity;
/// <summary>
/// The matrix that defines the reference frame for the explosion in space.
/// </summary>
- private readonly Matrix3 _spaceMatrix;
+ private readonly Matrix3x2 _spaceMatrix;
/// <summary>
/// Inverse of <see cref="_spaceMatrix"/>
/// </summary>
- private readonly Matrix3 _invSpaceMatrix;
+ private readonly Matrix3x2 _invSpaceMatrix;
/// <summary>
/// Have all the tiles on all the grids been processed?
List<ExplosionGridTileFlood> gridData,
List<float> tileSetIntensity,
MapCoordinates epicenter,
- Matrix3 spaceMatrix,
+ Matrix3x2 spaceMatrix,
int area,
float tileBreakScale,
int maxTileBreak,
});
_spaceMatrix = spaceMatrix;
- _invSpaceMatrix = Matrix3.Invert(spaceMatrix);
+ Matrix3x2.Invert(spaceMatrix, out _invSpaceMatrix);
}
foreach (var grid in gridData)
/// <param name="maxIntensity">The maximum intensity that the explosion can have at any given tile. This
/// effectively caps the damage that this explosion can do.</param>
/// <returns>A list of tile-sets and a list of intensity values which describe the explosion.</returns>
- private (int, List<float>, ExplosionSpaceTileFlood?, Dictionary<EntityUid, ExplosionGridTileFlood>, Matrix3)? GetExplosionTiles(
+ private (int, List<float>, ExplosionSpaceTileFlood?, Dictionary<EntityUid, ExplosionGridTileFlood>, Matrix3x2)? GetExplosionTiles(
MapCoordinates epicenter,
string typeID,
float totalIntensity,
Dictionary<EntityUid, HashSet<Vector2i>>? previousGridJump;
// variables for transforming between grid and space-coordinates
- var spaceMatrix = Matrix3.Identity;
+ var spaceMatrix = Matrix3x2.Identity;
var spaceAngle = Angle.Zero;
if (referenceGrid != null)
{
+using System.Numerics;
using Content.Shared.Explosion;
using Content.Shared.Explosion.Components;
using Robust.Server.GameObjects;
/// <summary>
/// Constructor for the shared <see cref="ExplosionEvent"/> using the server-exclusive explosion classes.
/// </summary>
- private EntityUid CreateExplosionVisualEntity(MapCoordinates epicenter, string prototype, Matrix3 spaceMatrix, ExplosionSpaceTileFlood? spaceData, IEnumerable<ExplosionGridTileFlood> gridData, List<float> iterationIntensity)
+ private EntityUid CreateExplosionVisualEntity(MapCoordinates epicenter, string prototype, Matrix3x2 spaceMatrix, ExplosionSpaceTileFlood? spaceData, IEnumerable<ExplosionGridTileFlood> gridData, List<float> iterationIntensity)
{
var explosionEntity = Spawn(null, MapCoordinates.Nullspace);
var comp = AddComp<ExplosionVisualsComponent>(explosionEntity);
+using System.Numerics;
using Content.Server.Chemistry.Containers.EntitySystems;
using Content.Server.Popups;
using Content.Shared.Chemistry.Components;
var userXform = Transform(user);
var targetPos = _transform.GetWorldPosition(target);
- var localPos = _transform.GetInvWorldMatrix(userXform).Transform(targetPos);
+ var localPos = Vector2.Transform(targetPos, _transform.GetInvWorldMatrix(userXform));
localPos = userXform.LocalRotation.RotateVec(localPos);
_melee.DoLunge(user, used, Angle.Zero, localPos, null, false);
{
var gridXform = Transform(gridUid);
- return new EntityCoordinates(gridUid, gridXform.InvWorldMatrix.Transform(toMap.Position));
+ return new EntityCoordinates(gridUid, Vector2.Transform(toMap.Position, gridXform.InvWorldMatrix));
}
return spawn;
+using System.Numerics;
using Content.Server.Access.Systems;
using Content.Server.DeviceNetwork;
using Content.Server.DeviceNetwork.Components;
if (transform.GridUid != null)
{
coordinates = new EntityCoordinates(transform.GridUid.Value,
- _transform.GetInvWorldMatrix(xformQuery.GetComponent(transform.GridUid.Value), xformQuery)
- .Transform(_transform.GetWorldPosition(transform, xformQuery)));
+ Vector2.Transform(_transform.GetWorldPosition(transform, xformQuery),
+ _transform.GetInvWorldMatrix(xformQuery.GetComponent(transform.GridUid.Value), xformQuery)));
}
else if (transform.MapUid != null)
{
return Vector2.Zero;
}
- endPos = startXform.InvWorldMatrix.Transform(endXform.WorldMatrix.Transform(endPos));
+ endPos = Vector2.Transform(Vector2.Transform(endPos, endXform.WorldMatrix), startXform.InvWorldMatrix);
}
// TODO: Numerics when we changeover.
private Vector2i GetOrigin(EntityCoordinates coordinates, EntityUid gridUid)
{
- var localPos = _transform.GetInvWorldMatrix(gridUid).Transform(coordinates.ToMapPos(EntityManager, _transform));
+ var localPos = Vector2.Transform(coordinates.ToMapPos(EntityManager, _transform), _transform.GetInvWorldMatrix(gridUid));
return new Vector2i((int) Math.Floor(localPos.X / ChunkSize), (int) Math.Floor(localPos.Y / ChunkSize));
}
return null;
}
- var localPos = xform.InvWorldMatrix.Transform(coordinates.ToMapPos(EntityManager, _transform));
+ var localPos = Vector2.Transform(coordinates.ToMapPos(EntityManager, _transform), xform.InvWorldMatrix);
var origin = GetOrigin(localPos);
if (!TryGetChunk(origin, comp, out var chunk))
var gen = _prototype.Index<DungeonPresetPrototype>(preset);
var dungeonRotation = _dungeon.GetDungeonRotation(seed);
- var dungeonTransform = Matrix3.CreateTransform(_position, dungeonRotation);
+ var dungeonTransform = Matrix3Helpers.CreateTransform(_position, dungeonRotation);
var roomPackProtos = new Dictionary<Vector2i, List<DungeonRoomPackPrototype>>();
foreach (var pack in _prototype.EnumeratePrototypes<DungeonRoomPackPrototype>())
var dungeon = new Dungeon();
var availablePacks = new List<DungeonRoomPackPrototype>();
var chosenPacks = new DungeonRoomPackPrototype?[gen.RoomPacks.Count];
- var packTransforms = new Matrix3[gen.RoomPacks.Count];
+ var packTransforms = new Matrix3x2[gen.RoomPacks.Count];
var packRotations = new Angle[gen.RoomPacks.Count];
// Actually pick the room packs and rooms
// Iterate every pack
random.Shuffle(availablePacks);
- Matrix3 packTransform = default!;
+ Matrix3x2 packTransform = default!;
var found = false;
DungeonRoomPackPrototype pack = default!;
var aRotation = dir.AsDir().ToAngle();
// Use this pack
- packTransform = Matrix3.CreateTransform(bounds.Center, aRotation);
+ packTransform = Matrix3Helpers.CreateTransform(bounds.Center, aRotation);
packRotations[i] = aRotation;
pack = aPack;
break;
{
var roomDimensions = new Vector2i(roomSize.Width, roomSize.Height);
Angle roomRotation = Angle.Zero;
- Matrix3 matty;
+ Matrix3x2 matty;
if (!roomProtos.TryGetValue(roomDimensions, out var roomProto))
{
if (!roomProtos.TryGetValue(roomDimensions, out roomProto))
{
- Matrix3.Multiply(packTransform, dungeonTransform, out matty);
+ matty = Matrix3x2.Multiply(packTransform, dungeonTransform);
for (var x = roomSize.Left; x < roomSize.Right; x++)
{
for (var y = roomSize.Bottom; y < roomSize.Top; y++)
{
- var index = matty.Transform(new Vector2(x, y) + grid.TileSizeHalfVector - packCenter).Floored();
+ var index = Vector2.Transform(new Vector2(x, y) + grid.TileSizeHalfVector - packCenter, matty).Floored();
tiles.Add((index, new Tile(_tileDefManager["FloorPlanetGrass"].TileId)));
}
}
roomRotation += Math.PI;
}
- var roomTransform = Matrix3.CreateTransform(roomSize.Center - packCenter, roomRotation);
+ var roomTransform = Matrix3Helpers.CreateTransform(roomSize.Center - packCenter, roomRotation);
- Matrix3.Multiply(roomTransform, packTransform, out matty);
- Matrix3.Multiply(matty, dungeonTransform, out var dungeonMatty);
+ matty = Matrix3x2.Multiply(roomTransform, packTransform);
+ var dungeonMatty = Matrix3x2.Multiply(matty, dungeonTransform);
// The expensive bit yippy.
_dungeon.SpawnRoom(gridUid, grid, dungeonMatty, room);
continue;
}
- var tilePos = dungeonMatty.Transform(new Vector2i(x + room.Offset.X, y + room.Offset.Y) + tileOffset);
+ var tilePos = Vector2.Transform(new Vector2i(x + room.Offset.X, y + room.Offset.Y) + tileOffset, dungeonMatty);
exterior.Add(tilePos.Floored());
}
}
for (var y = 0; y < room.Size.Y; y++)
{
var roomTile = new Vector2i(x + room.Offset.X, y + room.Offset.Y);
- var tilePos = dungeonMatty.Transform(roomTile + tileOffset);
+ var tilePos = Vector2.Transform(roomTile + tileOffset, dungeonMatty);
var tileIndex = tilePos.Floored();
roomTiles.Add(tileIndex);
bool clearExisting = false,
bool rotation = false)
{
- var originTransform = Matrix3.CreateTranslation(origin);
+ var originTransform = Matrix3Helpers.CreateTranslation(origin.X, origin.Y);
var roomRotation = Angle.Zero;
if (rotation)
roomRotation = GetRoomRotation(room, random);
}
- var roomTransform = Matrix3.CreateTransform((Vector2) room.Size / 2f, roomRotation);
- Matrix3.Multiply(roomTransform, originTransform, out var finalTransform);
+ var roomTransform = Matrix3Helpers.CreateTransform((Vector2) room.Size / 2f, roomRotation);
+ var finalTransform = Matrix3x2.Multiply(roomTransform, originTransform);
SpawnRoom(gridUid, grid, finalTransform, room, clearExisting);
}
public void SpawnRoom(
EntityUid gridUid,
MapGridComponent grid,
- Matrix3 roomTransform,
+ Matrix3x2 roomTransform,
DungeonRoomPrototype room,
bool clearExisting = false)
{
// go BRRNNTTT on existing stuff
if (clearExisting)
{
- var gridBounds = new Box2(roomTransform.Transform(Vector2.Zero), roomTransform.Transform(room.Size));
+ var gridBounds = new Box2(Vector2.Transform(Vector2.Zero, roomTransform), Vector2.Transform(room.Size, roomTransform));
_entitySet.Clear();
// Polygon skin moment
gridBounds = gridBounds.Enlarged(-0.05f);
var indices = new Vector2i(x + room.Offset.X, y + room.Offset.Y);
var tileRef = _maps.GetTileRef(templateMapUid, templateGrid, indices);
- var tilePos = roomTransform.Transform(indices + tileOffset);
+ var tilePos = Vector2.Transform(indices + tileOffset, roomTransform);
var rounded = tilePos.Floored();
_tiles.Add((rounded, tileRef.Tile));
}
foreach (var templateEnt in _lookup.GetEntitiesIntersecting(templateMapUid, bounds, LookupFlags.Uncontained))
{
var templateXform = _xformQuery.GetComponent(templateEnt);
- var childPos = roomTransform.Transform(templateXform.LocalPosition - roomCenter);
+ var childPos = Vector2.Transform(templateXform.LocalPosition - roomCenter, roomTransform);
var childRot = templateXform.LocalRotation + finalRoomRotation;
var protoId = _metaQuery.GetComponent(templateEnt).EntityPrototype?.ID;
// Offset by 0.5 because decals are offset from bot-left corner
// So we convert it to center of tile then convert it back again after transform.
// Do these shenanigans because 32x32 decals assume as they are centered on bottom-left of tiles.
- var position = roomTransform.Transform(decal.Coordinates + Vector2Helpers.Half - roomCenter);
+ var position = Vector2.Transform(decal.Coordinates + Vector2Helpers.Half - roomCenter, roomTransform);
position -= Vector2Helpers.Half;
// Umm uhh I love decals so uhhhh idk what to do about this
Vector2 srcLocal = sourceTrs.ParentUid == grid.Owner
? sourceTrs.LocalPosition
- : gridTrs.InvLocalMatrix.Transform(ray.Source);
+ : Vector2.Transform(ray.Source, gridTrs.InvLocalMatrix);
Vector2 dstLocal = destTrs.ParentUid == grid.Owner
? destTrs.LocalPosition
- : gridTrs.InvLocalMatrix.Transform(ray.Destination);
+ : Vector2.Transform(ray.Destination, gridTrs.InvLocalMatrix);
Vector2i sourceGrid = new(
(int) Math.Floor(srcLocal.X / grid.Comp.TileSize),
+using System.Numerics;
using Content.Shared.Salvage.Fulton;
using Robust.Shared.Containers;
using Robust.Shared.Map;
var metadata = MetaData(uid);
var oldCoords = xform.Coordinates;
var offset = _random.NextVector2(1.5f);
- var localPos = TransformSystem.GetInvWorldMatrix(beaconXform.ParentUid)
- .Transform(TransformSystem.GetWorldPosition(beaconXform)) + offset;
+ var localPos = Vector2.Transform(
+ TransformSystem.GetWorldPosition(beaconXform),
+ TransformSystem.GetInvWorldMatrix(beaconXform.ParentUid)) + offset;
TransformSystem.SetCoordinates(uid, new EntityCoordinates(beaconXform.ParentUid, localPos));
+using System.Numerics;
using Robust.Shared.Map;
namespace Content.Server.Shuttles.Events;
/// Raised when a shuttle has moved to FTL space.
/// </summary>
[ByRefEvent]
-public readonly record struct FTLStartedEvent(EntityUid Entity, EntityCoordinates TargetCoordinates, EntityUid? FromMapUid, Matrix3 FTLFrom, Angle FromRotation);
+public readonly record struct FTLStartedEvent(EntityUid Entity, EntityCoordinates TargetCoordinates, EntityUid? FromMapUid, Matrix3x2 FTLFrom, Angle FromRotation);
using System.Linq;
+using System.Numerics;
using Content.Server.Administration;
using Content.Server.DeviceNetwork.Components;
using Content.Server.DeviceNetwork.Systems;
foreach (var (ent, xform) in toDump)
{
var rotation = xform.LocalRotation;
- _transform.SetCoordinates(ent, new EntityCoordinates(args.FromMapUid!.Value, args.FTLFrom.Transform(xform.LocalPosition)));
+ _transform.SetCoordinates(ent, new EntityCoordinates(args.FromMapUid!.Value, Vector2.Transform(xform.LocalPosition, args.FTLFrom)));
_transform.SetWorldRotation(ent, args.FromRotation + rotation);
}
}
FixturesComponent shuttleFixtures,
MapGridComponent grid,
bool isMap,
- out Matrix3 matty,
+ out Matrix3x2 matty,
out Box2 shuttleDockedAABB,
out Angle gridRotation)
{
shuttleDockedAABB = Box2.UnitCentered;
gridRotation = Angle.Zero;
- matty = Matrix3.Identity;
+ matty = Matrix3x2.Identity;
if (shuttleDock.Docked ||
gridDock.Docked ||
var gridDockAngle = gridDockXform.LocalRotation.Opposite();
var offsetAngle = gridDockAngle - shuttleDockAngle;
- var stationDockMatrix = Matrix3.CreateInverseTransform(stationDockPos, shuttleDockAngle);
- var gridXformMatrix = Matrix3.CreateTransform(gridDockXform.LocalPosition, gridDockAngle);
- Matrix3.Multiply(in stationDockMatrix, in gridXformMatrix, out matty);
+ var stationDockMatrix = Matrix3Helpers.CreateInverseTransform(stationDockPos, shuttleDockAngle);
+ var gridXformMatrix = Matrix3Helpers.CreateTransform(gridDockXform.LocalPosition, gridDockAngle);
+ matty = Matrix3x2.Multiply(stationDockMatrix, gridXformMatrix);
if (!ValidSpawn(grid, matty, offsetAngle, shuttleFixtures, isMap))
return false;
}
// Can't just use the AABB as we want to get bounds as tight as possible.
- var gridPosition = new EntityCoordinates(targetGrid, matty.Transform(Vector2.Zero));
+ var gridPosition = new EntityCoordinates(targetGrid, Vector2.Transform(Vector2.Zero, matty));
var spawnPosition = new EntityCoordinates(targetGridXform.MapUid!.Value, gridPosition.ToMapPos(EntityManager, _transform));
// TODO: use tight bounds
/// <summary>
/// Checks whether the shuttle can warp to the specified position.
/// </summary>
- private bool ValidSpawn(MapGridComponent grid, Matrix3 matty, Angle angle, FixturesComponent shuttleFixturesComp, bool isMap)
+ private bool ValidSpawn(MapGridComponent grid, Matrix3x2 matty, Angle angle, FixturesComponent shuttleFixturesComp, bool isMap)
{
- var transform = new Transform(matty.Transform(Vector2.Zero), angle);
+ var transform = new Transform(Vector2.Transform(Vector2.Zero, matty), angle);
// Because some docking bounds are tight af need to check each chunk individually
foreach (var fix in shuttleFixturesComp.Fixtures.Values)
+using System.Numerics;
using Content.Server.Shuttles.Components;
using Content.Shared.Audio;
using Robust.Shared.Audio;
var otherXform = Transform(args.OtherEntity);
- var ourPoint = ourXform.InvWorldMatrix.Transform(args.WorldPoint);
- var otherPoint = otherXform.InvWorldMatrix.Transform(args.WorldPoint);
+ var ourPoint = Vector2.Transform(args.WorldPoint, ourXform.InvWorldMatrix);
+ var otherPoint = Vector2.Transform(args.WorldPoint, otherXform.InvWorldMatrix);
var ourVelocity = _physics.GetLinearVelocity(uid, ourPoint, ourBody, ourXform);
var otherVelocity = _physics.GetLinearVelocity(args.OtherEntity, otherPoint, otherBody, otherXform);
+using System.Numerics;
using Content.Server.Atmos.Components;
using Content.Server.Singularity.Components;
using Content.Shared.Ghost;
/// <param name="minRange">The minimum distance at which entities can be affected by the gravity pulse.</param>
/// <param name="baseMatrixDeltaV">The base velocity added to any entities within affected by the gravity pulse scaled by the displacement of those entities from the epicenter.</param>
/// <param name="xform">(optional) The transform of the entity at the epicenter of the gravitational pulse.</param>
- public void GravPulse(EntityUid uid, float maxRange, float minRange, in Matrix3 baseMatrixDeltaV, TransformComponent? xform = null)
+ public void GravPulse(EntityUid uid, float maxRange, float minRange, in Matrix3x2 baseMatrixDeltaV, TransformComponent? xform = null)
{
if (Resolve(uid, ref xform))
GravPulse(xform.Coordinates, maxRange, minRange, in baseMatrixDeltaV);
/// <param name="maxRange">The maximum distance at which entities can be affected by the gravity pulse.</param>
/// <param name="minRange">The minimum distance at which entities can be affected by the gravity pulse.</param>
/// <param name="baseMatrixDeltaV">The base velocity added to any entities within affected by the gravity pulse scaled by the displacement of those entities from the epicenter.</param>
- public void GravPulse(EntityCoordinates entityPos, float maxRange, float minRange, in Matrix3 baseMatrixDeltaV)
+ public void GravPulse(EntityCoordinates entityPos, float maxRange, float minRange, in Matrix3x2 baseMatrixDeltaV)
=> GravPulse(entityPos.ToMap(EntityManager, _transform), maxRange, minRange, in baseMatrixDeltaV);
/// <summary>
/// <param name="maxRange">The maximum distance at which entities can be affected by the gravity pulse.</param>
/// <param name="minRange">The minimum distance at which entities can be affected by the gravity pulse. Exists to prevent div/0 errors.</param>
/// <param name="baseMatrixDeltaV">The base velocity added to any entities within affected by the gravity pulse scaled by the displacement of those entities from the epicenter.</param>
- public void GravPulse(MapCoordinates mapPos, float maxRange, float minRange, in Matrix3 baseMatrixDeltaV)
+ public void GravPulse(MapCoordinates mapPos, float maxRange, float minRange, in Matrix3x2 baseMatrixDeltaV)
{
if (mapPos == MapCoordinates.Nullspace)
return; // No gravpulses in nullspace please.
continue;
var scaling = (1f / distance2) * physics.Mass; // TODO: Variable falloff gradiants.
- _physics.ApplyLinearImpulse(entity, (displacement * baseMatrixDeltaV) * scaling, body: physics);
+ _physics.ApplyLinearImpulse(entity, Vector2.Transform(displacement, baseMatrixDeltaV) * scaling, body: physics);
}
}
/// <param name="baseRadialDeltaV">The base amount of velocity that will be added to entities in range towards the epicenter of the pulse.</param>
/// <param name="baseTangentialDeltaV">The base amount of velocity that will be added to entities in range counterclockwise relative to the epicenter of the pulse.</param>
public void GravPulse(MapCoordinates mapPos, float maxRange, float minRange = 0.0f, float baseRadialDeltaV = 0.0f, float baseTangentialDeltaV = 0.0f)
- => GravPulse(mapPos, maxRange, minRange, new Matrix3(
- baseRadialDeltaV, +baseTangentialDeltaV, 0.0f,
- -baseTangentialDeltaV, baseRadialDeltaV, 0.0f,
- 0.0f, 0.0f, 1.0f
+ => GravPulse(mapPos, maxRange, minRange, new Matrix3x2(
+ baseRadialDeltaV, -baseTangentialDeltaV, 0.0f,
+ +baseTangentialDeltaV, baseRadialDeltaV, 0.0f
));
#endregion GravPulse
var (_, gridRot, gridInvMatrix) = TransformSystem.GetWorldPositionRotationInvMatrix(gridXform, xformQuery);
fromCoordinates = new EntityCoordinates(gridUid.Value,
- gridInvMatrix.Transform(fromCoordinates.ToMapPos(EntityManager, TransformSystem)));
+ Vector2.Transform(fromCoordinates.ToMapPos(EntityManager, TransformSystem), gridInvMatrix));
// Use the fallback angle I guess?
angle -= gridRot;
+using System.Numerics;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
public Dictionary<EntityUid, Dictionary<int, List<Vector2i>>> Tiles = new();
public List<float> Intensity = new();
public string ExplosionType = string.Empty;
- public Matrix3 SpaceMatrix;
+ public Matrix3x2 SpaceMatrix;
public ushort SpaceTileSize;
}
public Dictionary<NetEntity, Dictionary<int, List<Vector2i>>> Tiles;
public List<float> Intensity;
public string ExplosionType = string.Empty;
- public Matrix3 SpaceMatrix;
+ public Matrix3x2 SpaceMatrix;
public ushort SpaceTileSize;
public ExplosionVisualsState(
List<float> intensity,
Dictionary<int, List<Vector2i>>? spaceTiles,
Dictionary<NetEntity, Dictionary<int, List<Vector2i>>> tiles,
- Matrix3 spaceMatrix,
+ Matrix3x2 spaceMatrix,
ushort spaceTileSize)
{
Epicenter = epicenter;
var shapes = GetItemShape(entity);
var boundingShape = shapes.GetBoundingBox();
var boundingCenter = ((Box2) boundingShape).Center;
- var matty = Matrix3.CreateTransform(boundingCenter, rotation);
+ var matty = Matrix3Helpers.CreateTransform(boundingCenter, rotation);
var drift = boundingShape.BottomLeft - matty.TransformBox(boundingShape).BottomLeft;
var adjustedShapes = new List<Box2i>();
var size = grid.TileSize;
var localPos = new Vector2(indices.X * size + (size / 2f), indices.Y * size + (size / 2f));
- var worldPos = matrix.Transform(localPos);
+ var worldPos = Vector2.Transform(localPos, matrix);
// This is scaled to 95 % so it doesn't encompass walls on other tiles.
var tileAabb = Box2.UnitCentered.Scale(0.95f * size);
return;
var invMatrix = TransformSystem.GetInvWorldMatrix(userXform);
- var localPos = invMatrix.Transform(coordinates.Position);
+ var localPos = Vector2.Transform(coordinates.Position, invMatrix);
if (localPos.LengthSquared() <= 0f)
return;
projects / space-station-14.git / commitdiff