DarthAffe/Artemis
1
0 Fork 0
mirror of https://github.com/Artemis-RGB/Artemis synced 2026-11-12 11:56:30 +00:00
Code Issues Releases Wiki Activity

Simplified the different properties used for layer/shape rendering

Browse Source 
Cleaned up UI layer shape service
This commit is contained in:
SpoinkyNL committed 2020-01-31 00:02:01 +01:00
1 parent f57aca3475
commit fd9dd626f8
17 files changed
+192 -284
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/Artemis.UI/Services/LayerShapeService.cs
+68 -149
View File
@@ -21,121 +21,56 @@ namespace Artemis.UI.Services
}
/// <inheritdoc />
public Rect GetLayerRenderRect(Layer layer)
public Rect GetLayerBounds(Layer layer)
{
// Adjust the render rectangle for the difference in render scale
var renderScale = _settingsService.GetSetting("Core.RenderScale", 1.0).Value;
return new Rect(
layer.Rectangle.Left / renderScale * 1,
layer.Rectangle.Top / renderScale * 1,
Math.Max(0, layer.Rectangle.Width / renderScale * 1),
Math.Max(0, layer.Rectangle.Height / renderScale * 1)
layer.Bounds.Left / renderScale * 1,
layer.Bounds.Top / renderScale * 1,
Math.Max(0, layer.Bounds.Width / renderScale * 1),
Math.Max(0, layer.Bounds.Height / renderScale * 1)
);
}
public Rect GetLayerRect(Layer layer)
/// <inheritdoc />
public Rect GetLayerShapeBounds(LayerShape layerShape)
{
// Adjust the render rectangle for the difference in render scale
var renderScale = _settingsService.GetSetting("Core.RenderScale", 1.0).Value;
return new Rect(
layer.AbsoluteRectangle.Left / renderScale * 1,
layer.AbsoluteRectangle.Top / renderScale * 1,
Math.Max(0, layer.AbsoluteRectangle.Width / renderScale * 1),
Math.Max(0, layer.AbsoluteRectangle.Height / renderScale * 1)
layerShape.Bounds.Left / renderScale * 1,
layerShape.Bounds.Top / renderScale * 1,
Math.Max(0, layerShape.Bounds.Width / renderScale * 1),
Math.Max(0, layerShape.Bounds.Height / renderScale * 1)
);
}
/// <inheritdoc />
public SKPath GetLayerPath(Layer layer, bool includeTranslation, bool includeScale, bool includeRotation)
public Point GetLayerAnchor(Layer layer)
{
var layerRect = GetLayerRenderRect(layer).ToSKRect();
var shapeRect = GetShapeUntransformedRect(layer.LayerShape).ToSKRect();
// Apply transformation like done by the core during layer rendering
var anchor = GetLayerAnchor(layer, true);
var relativeAnchor = GetLayerAnchor(layer, false);
// Translation originates from the unscaled center of the shape and is tied to the anchor
var x = layer.PositionProperty.CurrentValue.X * layerRect.Width - shapeRect.Width / 2 - relativeAnchor.X;
var y = layer.PositionProperty.CurrentValue.Y * layerRect.Height - shapeRect.Height / 2 - relativeAnchor.Y;
var path = new SKPath();
path.AddRect(shapeRect);
if (includeTranslation)
path.Transform(SKMatrix.MakeTranslation(x, y));
if (includeScale)
path.Transform(SKMatrix.MakeScale(layer.SizeProperty.CurrentValue.Width, layer.SizeProperty.CurrentValue.Height, anchor.X, anchor.Y));
if (includeRotation)
path.Transform(SKMatrix.MakeRotationDegrees(layer.RotationProperty.CurrentValue, anchor.X, anchor.Y));
return path;
}
public void ReverseLayerPath(Layer layer, SKPath path)
{
var layerRect = GetLayerRenderRect(layer).ToSKRect();
var shapeRect = GetShapeUntransformedRect(layer.LayerShape).ToSKRect();
// Apply transformation like done by the core during layer rendering
var anchor = GetLayerAnchor(layer, true);
var relativeAnchor = GetLayerAnchor(layer, false);
// Translation originates from the unscaled center of the shape and is tied to the anchor
var x = layer.PositionProperty.CurrentValue.X * layerRect.Width - shapeRect.Width / 2 - relativeAnchor.X;
var y = layer.PositionProperty.CurrentValue.Y * layerRect.Height - shapeRect.Height / 2 - relativeAnchor.Y;
SKMatrix.MakeScale(layer.SizeProperty.CurrentValue.Width, layer.SizeProperty.CurrentValue.Height, anchor.X, anchor.Y).TryInvert(out var scale);
path.Transform(SKMatrix.MakeRotationDegrees(layer.RotationProperty.CurrentValue * -1, anchor.X, anchor.Y));
path.Transform(scale);
path.Transform(SKMatrix.MakeTranslation(x * -1, y * -1));
}
/// <inheritdoc />
public SKPoint GetLayerAnchor(Layer layer, bool absolute)
{
var layerRect = GetLayerRect(layer);
if (absolute)
{
var position = layer.PositionProperty.CurrentValue;
position.X = (float) (position.X * layerRect.Width);
position.Y = (float) (position.Y * layerRect.Height);
var shapeRect = GetShapeUntransformedRect(layer.LayerShape);
return new SKPoint((float) (position.X + shapeRect.Left), (float) (position.Y + shapeRect.Top));
}
var layerBounds = GetLayerBounds(layer);
// TODO figure out what else is needed, position should matter here
var anchor = layer.AnchorPointProperty.CurrentValue;
anchor.X = (float) (anchor.X * layerRect.Width);
anchor.Y = (float) (anchor.Y * layerRect.Height);
return new SKPoint(anchor.X, anchor.Y);
}
anchor.X = (float) (anchor.X * layerBounds.Width);
anchor.Y = (float) (anchor.Y * layerBounds.Height);
public void SetLayerAnchor(Layer layer, SKPoint point, bool absolute, TimeSpan? time)
{
var layerRect = GetLayerRect(layer);
if (absolute)
{
var shapeRect = GetShapeUntransformedRect(layer.LayerShape);
var position = new SKPoint((float) ((point.X - shapeRect.Left) / layerRect.Width), (float) ((point.Y - shapeRect.Top) / layerRect.Height));
layer.PositionProperty.SetCurrentValue(position, time);
}
var anchor = new SKPoint((float) (point.X / layerRect.Width), (float) (point.Y / layerRect.Height));
layer.AnchorPointProperty.SetCurrentValue(anchor, time);
return new Point(anchor.X * layerBounds.Width, anchor.Y * layerBounds.Height);
}
/// <inheritdoc />
public TransformGroup GetLayerTransformGroup(Layer layer)
{
var layerRect = GetLayerRenderRect(layer).ToSKRect();
var shapeRect = GetShapeUntransformedRect(layer.LayerShape).ToSKRect();
var layerBounds = GetLayerBounds(layer).ToSKRect();
var shapeBounds = GetLayerShapeBounds(layer.LayerShape).ToSKRect();
// Apply transformation like done by the core during layer rendering
var anchor = GetLayerAnchor(layer, true);
var anchor = GetLayerAnchor(layer);
// Translation originates from the unscaled center of the shape and is tied to the anchor
var x = layer.PositionProperty.CurrentValue.X * layerRect.Width - shapeRect.Width / 2 - GetLayerAnchor(layer, false).X;
var y = layer.PositionProperty.CurrentValue.Y * layerRect.Height - shapeRect.Height / 2 - GetLayerAnchor(layer, false).Y;
var x = layer.PositionProperty.CurrentValue.X * layerBounds.Width - shapeBounds.Width / 2 - anchor.X;
var y = layer.PositionProperty.CurrentValue.Y * layerBounds.Height - shapeBounds.Height / 2 - anchor.Y;
var transformGroup = new TransformGroup();
transformGroup.Children.Add(new TranslateTransform(x, y));
@@ -146,27 +81,30 @@ namespace Artemis.UI.Services
}
/// <inheritdoc />
public Rect GetShapeUntransformedRect(LayerShape layerShape)
public SKPath GetLayerPath(Layer layer, bool includeTranslation, bool includeScale, bool includeRotation)
{
if (layerShape == null)
return Rect.Empty;
var layerBounds = GetLayerBounds(layer).ToSKRect();
var shapeBounds = GetLayerShapeBounds(layer.LayerShape).ToSKRect();
// Adjust the render rectangle for the difference in render scale
var renderScale = _settingsService.GetSetting("Core.RenderScale", 1.0).Value;
return new Rect(
layerShape.RenderRectangle.Left / renderScale * 1,
layerShape.RenderRectangle.Top / renderScale * 1,
Math.Max(0, layerShape.RenderRectangle.Width / renderScale * 1),
Math.Max(0, layerShape.RenderRectangle.Height / renderScale * 1)
);
// Apply transformation like done by the core during layer rendering
var anchor = GetLayerAnchor(layer).ToSKPoint();
// Translation originates from the unscaled center of the shape and is tied to the anchor
var x = layer.PositionProperty.CurrentValue.X * layerBounds.Width - shapeBounds.Width / 2 - anchor.X;
var y = layer.PositionProperty.CurrentValue.Y * layerBounds.Height - shapeBounds.Height / 2 - anchor.Y;
var path = new SKPath();
path.AddRect(shapeBounds);
if (includeTranslation)
path.Transform(SKMatrix.MakeTranslation(x, y));
if (includeScale)
path.Transform(SKMatrix.MakeScale(layer.SizeProperty.CurrentValue.Width, layer.SizeProperty.CurrentValue.Height, anchor.X, anchor.Y));
if (includeRotation)
path.Transform(SKMatrix.MakeRotationDegrees(layer.RotationProperty.CurrentValue, anchor.X, anchor.Y));
return path;
}
/// <inheritdoc />
public Rect GetShapeTransformedRect(LayerShape layerShape)
{
var path = GetLayerPath(layerShape.Layer, true, true, false);
return path.Bounds.ToRect();
}
/// <inheritdoc />
public void SetShapeBaseFromRectangle(LayerShape layerShape, Rect rect)
@@ -177,16 +115,16 @@ namespace Artemis.UI.Services
return;
}
var layerRect = GetLayerRenderRect(layerShape.Layer).ToSKRect();
var layerBounds = GetLayerBounds(layerShape.Layer).ToSKRect();
// Compensate for the current value of the position transformation
rect.X += rect.Width / 2;
rect.X -= layerRect.Width * layerShape.Layer.PositionProperty.CurrentValue.X;
rect.X += layerRect.Width * layerShape.Layer.AnchorPointProperty.CurrentValue.X * layerShape.Layer.SizeProperty.CurrentValue.Width;
rect.X -= layerBounds.Width * layerShape.Layer.PositionProperty.CurrentValue.X;
rect.X += layerBounds.Width * layerShape.Layer.AnchorPointProperty.CurrentValue.X * layerShape.Layer.SizeProperty.CurrentValue.Width;
rect.Y += rect.Height / 2;
rect.Y -= layerRect.Height * layerShape.Layer.PositionProperty.CurrentValue.Y;
rect.Y += layerRect.Height * layerShape.Layer.AnchorPointProperty.CurrentValue.Y * layerShape.Layer.SizeProperty.CurrentValue.Height;
rect.Y -= layerBounds.Height * layerShape.Layer.PositionProperty.CurrentValue.Y;
rect.Y += layerBounds.Height * layerShape.Layer.AnchorPointProperty.CurrentValue.Y * layerShape.Layer.SizeProperty.CurrentValue.Height;
// Compensate for the current value of the size transformation
rect.Height /= layerShape.Layer.SizeProperty.CurrentValue.Height;
@@ -195,10 +133,10 @@ namespace Artemis.UI.Services
// Adjust the provided rect for the difference in render scale
var renderScale = _settingsService.GetSetting("Core.RenderScale", 1.0).Value;
layerShape.ScaledRectangle = SKRect.Create(
100f / layerShape.Layer.AbsoluteRectangle.Width * ((float) (rect.Left * renderScale) - layerShape.Layer.AbsoluteRectangle.Left) / 100f,
100f / layerShape.Layer.AbsoluteRectangle.Height * ((float) (rect.Top * renderScale) - layerShape.Layer.AbsoluteRectangle.Top) / 100f,
100f / layerShape.Layer.AbsoluteRectangle.Width * (float) (rect.Width * renderScale) / 100f,
100f / layerShape.Layer.AbsoluteRectangle.Height * (float) (rect.Height * renderScale) / 100f
100f / layerShape.Layer.Bounds.Width * ((float) (rect.Left * renderScale) - layerShape.Layer.Bounds.Left) / 100f,
100f / layerShape.Layer.Bounds.Height * ((float) (rect.Top * renderScale) - layerShape.Layer.Bounds.Top) / 100f,
100f / layerShape.Layer.Bounds.Width * (float) (rect.Width * renderScale) / 100f,
100f / layerShape.Layer.Bounds.Height * (float) (rect.Height * renderScale) / 100f
);
layerShape.CalculateRenderProperties();
}
@@ -210,14 +148,14 @@ namespace Artemis.UI.Services
if (absolute)
{
return new SKPoint(
100f / layer.AbsoluteRectangle.Width * ((float) (point.X * renderScale) - layer.AbsoluteRectangle.Left) / 100f,
100f / layer.AbsoluteRectangle.Height * ((float) (point.Y * renderScale) - layer.AbsoluteRectangle.Top) / 100f
100f / layer.Bounds.Width * ((float) (point.X * renderScale) - layer.Bounds.Left) / 100f,
100f / layer.Bounds.Height * ((float) (point.Y * renderScale) - layer.Bounds.Top) / 100f
);
}
return new SKPoint(
100f / layer.AbsoluteRectangle.Width * (float) (point.X * renderScale) / 100f,
100f / layer.AbsoluteRectangle.Height * (float) (point.Y * renderScale) / 100f
100f / layer.Bounds.Width * (float) (point.X * renderScale) / 100f,
100f / layer.Bounds.Height * (float) (point.Y * renderScale) / 100f
);
}
}
@@ -225,40 +163,25 @@ namespace Artemis.UI.Services
public interface ILayerEditorService : IArtemisUIService
{
/// <summary>
/// Returns an relative and scaled rectangle for the given layer that is corrected for the current render scale.
/// Returns the layer's bounds, corrected for the current render scale.
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
Rect GetLayerRenderRect(Layer layer);
Rect GetLayerBounds(Layer layer);
/// <summary>
/// Returns an absolute and scaled rectangle for the given layer that is corrected for the current render scale.
/// Returns the layer's anchor, corrected for the current render scale.
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
Rect GetLayerRect(Layer layer);
Point GetLayerAnchor(Layer layer);
/// <summary>
/// Returns an absolute and scaled rectangular path for the given layer that is corrected for the current render scale.
/// Returns the layer shape's bounds, corrected for the current render scale.
/// </summary>
/// <param name="layer"></param>
/// <param name="includeTranslation"></param>
/// <param name="includeScale"></param>
/// <param name="includeRotation"></param>
/// <param name="layerShape"></param>
/// <returns></returns>
SKPath GetLayerPath(Layer layer, bool includeTranslation, bool includeScale, bool includeRotation);
void ReverseLayerPath(Layer layer, SKPath path);
/// <summary>
/// Returns an absolute and scaled anchor for the given layer, optionally with the translation applied.
/// </summary>
/// <param name="layer"></param>
/// <param name="absolute"></param>
/// <returns></returns>
SKPoint GetLayerAnchor(Layer layer, bool absolute);
void SetLayerAnchor(Layer layer, SKPoint point, bool absolute, TimeSpan? time);
Rect GetLayerShapeBounds(LayerShape layerShape);
/// <summary>
/// Creates a WPF transform group that contains all the transformations required to render the provided layer.
@@ -269,18 +192,14 @@ namespace Artemis.UI.Services
TransformGroup GetLayerTransformGroup(Layer layer);
/// <summary>
/// Returns an absolute and scaled rectangle for the given shape that is corrected for the current render scale without
/// any transformations applied.
/// Returns an absolute and scaled rectangular path for the given layer that is corrected for the current render scale.
/// </summary>
/// <param name="layer"></param>
/// <param name="includeTranslation"></param>
/// <param name="includeScale"></param>
/// <param name="includeRotation"></param>
/// <returns></returns>
Rect GetShapeUntransformedRect(LayerShape layerShape);
/// <summary>
/// Returns an absolute and scaled rectangle for the given shape that is corrected for the current render scale with
/// translation and scale transformations applied.
/// </summary>
/// <returns></returns>
Rect GetShapeTransformedRect(LayerShape layerShape);
SKPath GetLayerPath(Layer layer, bool includeTranslation, bool includeScale, bool includeRotation);
/// <summary>
/// Sets the base properties of the given shape to match the provided unscaled rectangle. The rectangle is corrected