public static SkeletonLayerAnimation MakeSlidingAnimation(GradientDirection direction, double duration = 1.5)
{
return((layer) =>
{
var startValues = direction.StartPoint();
var endValues = direction.EndPoint();
var startPointAnim = CABasicAnimation.FromKeyPath(nameof(CAGradientLayer.StartPoint));
startPointAnim.From = NSValue.FromCGPoint(startValues.from);
startPointAnim.To = NSValue.FromCGPoint(startValues.to);
var endPointAnim = CABasicAnimation.FromKeyPath(nameof(CAGradientLayer.EndPoint));
endPointAnim.From = NSValue.FromCGPoint(endValues.from);
endPointAnim.To = NSValue.FromCGPoint(endValues.to);
var animGroup = new CAAnimationGroup
{
Animations = new[] { startPointAnim, endPointAnim },
Duration = duration,
TimingFunction = CAMediaTimingFunction.FromName(CAMediaTimingFunction.EaseIn),
RepeatCount = float.MaxValue
};
return animGroup;
});
}
public LinearGradientPair(PointF stop1, Color c1, PointF stop2, Color c2)
{
this.c1 = c1;
this.c2 = c2;
this.x1 = stop1.X;
this.y1 = stop1.Y;
this.x2 = stop2.X;
this.y2 = stop2.Y;
float dx = stop2.X - stop1.X;
float dy = stop2.Y - stop1.Y;
if (dx == 0)
{
//vertical
Direction = GradientDirection.Vertical;
_distance = Math.Abs(dy);
}
else if (dy == 0)
{
//horizontal
Direction = GradientDirection.Horizontal;
_distance = Math.Abs(dx);
}
else
{
Direction = GradientDirection.Angle;
_distance = Math.Sqrt(dx * dx + dy * dy);
}
Angle = (double)Math.Atan2(dy, dx);
steps = 256;
}
public static (CGPoint @from, CGPoint to) StartPoint(this GradientDirection This)
{
switch (This)
{
case GradientDirection.LeftRight:
return(new CGPoint(-1, 0.5), new CGPoint(1, 0.5));
case GradientDirection.RightLeft:
return(new CGPoint(1, 0.5), new CGPoint(-1, 0.5));
case GradientDirection.TopBottom:
return(new CGPoint(0.5, -1), new CGPoint(0.5, 1));
case GradientDirection.BottomTop:
return(new CGPoint(0.5, 1), new CGPoint(0.5, -1));
case GradientDirection.TopLeftBottomRight:
return(new CGPoint(-1, -1), new CGPoint(1, 1));
case GradientDirection.BottomRightTopLeft:
return(new CGPoint(1, 1), new CGPoint(-1, -1));
default:
throw new NotSupportedException();
}
}
private static (GradientDirection direction, int intensity) ResolveDirectionAndIntesity(int sumVectorX, int sumVectorY)
{
GradientDirection resultDirection = GradientDirection.none;
int resultIntensity = 0;
if (sumVectorX == 0 && sumVectorY != 0)
{
resultDirection = GradientDirection.vertical;
}
if (sumVectorX != 0 && sumVectorY == 0)
{
resultDirection = GradientDirection.horizontal;
}
DetectQuadrant1(sumVectorX, sumVectorY, ref resultDirection);
DetectQuadrant2(sumVectorX, sumVectorY, ref resultDirection);
DetectQuadrant3(sumVectorX, sumVectorY, ref resultDirection);
DetectQuadrant4(sumVectorX, sumVectorY, ref resultDirection);
resultIntensity = (int)Math.Sqrt((sumVectorX * sumVectorX) + (sumVectorY * sumVectorY));
return(resultDirection, resultIntensity);
}
private static void DetectQuadrant4(int sumVectorX, int sumVectorY, ref GradientDirection resultDirection)
{
if (sumVectorX < 0 && sumVectorY > 0)
{
int absSumVectorX = BasicHelpers.FastAbs(sumVectorX);
if (sumVectorY > absSumVectorX)
{
if (absSumVectorX * 2 < sumVectorY)
{
resultDirection = GradientDirection.vertical;
}
else
{
resultDirection = GradientDirection.askewFall;
}
}
else
{
if (absSumVectorX < sumVectorY * 2)
{
resultDirection = GradientDirection.horizontal;
}
else
{
resultDirection = GradientDirection.askewFall;
}
}
}
}
/// <summary>
/// Creates a linear gradient texture.
/// </summary>
/// <param name="start">Starting color.</param>
/// <param name="destination">Destination color.</param>
/// <param name="gradientDirection">Direction of the gradient.</param>
public LinearGradientTextureResource(
Color4 start,
Color4 destination,
GradientDirection gradientDirection)
: base(
new GDI2D.LinearGradientBrush(GetStartPoint(gradientDirection, 32, 32), GetTargetPoint(gradientDirection, 32, 32), start.ToGdiColor(), destination.ToGdiColor()),
32, 32)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GradientBackgroundComponent"/> class.
/// </summary>
public GradientBackgroundComponent()
{
m_gradientDirection = DEFAULT_GRADIENT_DIR;
m_textureWidth = DEFAULT_WDITH;
m_textureHeight = DEFAULT_HEIGHT;
m_colorStart = Color4.WhiteSmoke;
m_colorEnd = Color4.Gray;
base.TargetLayer = DEFAULT_LAYER;
base.TargetLayerOrderID = DEFAULT_LAYER_ORDER_ID;
}
/// <summary>
/// Gets the target-point of the gradient.
/// </summary>
private static GDI.Point GetTargetPoint(GradientDirection direction, int width, int height)
{
switch (direction)
{
case GradientDirection.LeftToRight:
return(new GDI.Point(width, 0));
case GradientDirection.TopToBottom:
return(new GDI.Point(0, height));
case GradientDirection.Directional:
return(new GDI.Point(width, height));
}
return(new GDI.Point(width, height));
}
private UIImage CreateGradientBackground(Color startColor, Color endColor, GradientDirection direction)
{
var gradientLayer = new CAGradientLayer();
gradientLayer.Bounds = NavigationController.NavigationBar.Bounds;
gradientLayer.Colors = new CGColor[] { startColor.ToCGColor(), endColor.ToCGColor() };
switch (direction)
{
case GradientDirection.LeftToRight:
gradientLayer.StartPoint = new CGPoint(0.0, 0.5);
gradientLayer.EndPoint = new CGPoint(1.0, 0.5);
break;
case GradientDirection.RightToLeft:
gradientLayer.StartPoint = new CGPoint(1.0, 0.5);
gradientLayer.EndPoint = new CGPoint(0.0, 0.5);
break;
case GradientDirection.BottomToTop:
gradientLayer.StartPoint = new CGPoint(1.0, 1.0);
gradientLayer.EndPoint = new CGPoint(0.0, 0.0);
break;
default:
gradientLayer.StartPoint = new CGPoint(1.0, 0.0);
gradientLayer.EndPoint = new CGPoint(0.0, 1.0);
break;
}
UIGraphics.BeginImageContext(gradientLayer.Bounds.Size);
gradientLayer.RenderInContext(UIGraphics.GetCurrentContext());
UIImage image = UIGraphics.GetImageFromCurrentImageContext();
UIGraphics.EndImageContext();
return(image);
}
public static void GradientFill(Graphics graphics, Rectangle target,
Color startColor, Color endColor,
GradientDirection direction)
{
if (!GradientFillSupported)
{
return;
}
var hdc = graphics.GetHdc();
try
{
var vertices = new TriVertex[]
{
new TriVertex(target.Left, target.Top, startColor),
new TriVertex(target.Right, target.Bottom, endColor)
};
var rectangles = new GradientRect[]
{
new GradientRect()
{
UpperLeft = 0,
LowerRight = 1
}
};
GradientFill(hdc, vertices, 2, rectangles, 1,
direction == GradientDirection.Horizontal ?
GRADIENT_FILL_RECT_H : GRADIENT_FILL_RECT_V);
}
finally
{
graphics.ReleaseHdc(hdc);
}
}
public static SkeletonLayerAnimation SlidingAnimation(this GradientDirection This, double duration = 1.5)
{
return(SkeletonAnimationBuilder.MakeSlidingAnimation(This, duration));
}
public EdgePoint(GradientDirection direction, int intensity)
{
this.Direction = direction;
this.Intensity = intensity;
}
public BrushData()
{
this.Name = "Gradient 1";
this.Data = "255,68,120,194\t0\n255,13,58,122\t0.5\n255,6,36,78\t0.5\n255,12,76,159\t1";
this.Direction = BrushData.GradientDirection.Vertical;
}
public GradientColorFill(UmlColor first, UmlColor second, GradientDirection direction)
{
_first = first;
_second = second;
_direction = direction;
}
public static void SetGradientDirection(BindableObject view, GradientDirection value) => view.SetValue(GradientDirectionProperty, value);
internal GradientShaderFactory(int[] colors, GradientDirection direction)
{
this.colors = colors;
this.direction = direction;
}
public BrushData(string data, GradientDirection direction)
{
this.Data = data;
this.Direction = direction;
}
public BrushData(string data, GradientDirection direction)
{
this.Data = data;
this.Direction = direction;
}
/// <summary>
/// Paints a the specified rectangle with the colors specified.
/// </summary>
/// <param name="device"></param>
/// <param name="rectangle"></param>
/// <param name="buffer"></param>
/// <param name="color1"></param>
/// <param name="color2"></param>
/// <param name="gradientDirection"></param>
public static void PaintColoredRectangle(Device device, Rectangle rectangle, VertexBuffer buffer, Color color1, Color color2, GradientDirection gradientDirection)
{
GraphicsBuffer <TransformedColored> data = buffer.Lock <TransformedColored>(0, 4, LockFlags.None);
int topLeftColor = color1.ToArgb();
int topRightColor = gradientDirection == GradientDirection.Horizontal ? color2.ToArgb() : color1.ToArgb();
int bottomLeftColor = gradientDirection == GradientDirection.Horizontal ? color1.ToArgb() : color2.ToArgb();
int bottomRightColor = color2.ToArgb();
data[0] = new TransformedColored(rectangle.X, rectangle.Y, .5f, 0, topLeftColor);
data[1] = new TransformedColored(rectangle.Right, rectangle.Y, .5f, 0, topRightColor);
data[2] = new TransformedColored(rectangle.X, rectangle.Bottom, .5f, 0, bottomLeftColor);
data[3] = new TransformedColored(rectangle.Right, rectangle.Bottom, .5f, 0, bottomRightColor);
buffer.Unlock();
device.RenderState.ZBufferWriteEnable = false;
device.RenderState.AlphaBlendEnable = false;
device.RenderState.CullMode = Cull.None;
device.VertexFormat = TransformedColored.Format;
device.SetStreamSource(0, buffer, 0);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
}
