/// <summary>
/// Max pool layer.
/// The max pool layers function is to progressively reduce the spatial size of the representation
/// to reduce the amount of parameters and computation in the network.
/// The reduction is only done on the width and height. Depth dimension is preserved.
/// </summary>
/// <param name="poolWidth">The width of the pool area (default is 2)</param>
/// <param name="poolHeight">The height of the pool area (default is 2)</param>
/// <param name="stride">Controls the distance between each neighbouring pool areas (default is 2)</param>
/// <param name="padWidth">Zero padding for the width dimension (default is 0)</param>
/// <param name="padHeight">Zero padding for the height dimension (default is 0)</param>
public MaxPool2DLayer(int poolWidth, int poolHeight, int stride, int padWidth, int padHeight)
{
if (poolWidth < 1)
{
throw new ArgumentException("poolWidth is less than 1: " + poolWidth);
}
if (poolHeight < 1)
{
throw new ArgumentException("poolHeight is less than 1: " + poolHeight);
}
if (padWidth < 0)
{
throw new ArgumentException("padWidth is less than 0: " + padWidth);
}
if (padHeight < 0)
{
throw new ArgumentException("padHeight is less than 0: " + padHeight);
}
if (stride < 1)
{
throw new ArgumentException("stride is less than 0: " + stride);
}
m_poolWidth = poolWidth;
m_poolHeight = poolHeight;
m_stride = stride;
m_padWidth = padWidth;
m_padHeight = padHeight;
BorderMode = BorderMode.Undefined;
ActivationFunc = Activation.Undefined;
}
public void CopyFrom(RectStyle other)
{
color = other.color;
enableGradient = other.enableGradient;
gradientAngle = other.gradientAngle;
gradient?.Clear();
if (other.gradient != null)
{
if (gradient == null)
{
gradient = new Gradient();
}
foreach (var keyPoint in other.gradient)
{
gradient.Add(keyPoint);
}
}
borderMode = other.borderMode;
borderColor = other.borderColor;
borderWidth = other.borderWidth;
cornerRadius = other.cornerRadius;
enableBoxShadow = other.enableBoxShadow;
boxShadowColor = other.boxShadowColor;
boxShadowBlurRadius = other.boxShadowBlurRadius;
boxShadowOffset = other.boxShadowOffset;
boxShadowInner = other.boxShadowInner;
}
public KenPanel()
{
this.borderMode = BorderMode.None;
this.borderColor = Color.Black;
this.border3DStyle = System.Windows.Forms.Border3DStyle.Etched;
this.borderSide = ToolStripStatusLabelBorderSides.All;
}
/// <summary>
/// Max pool layer.
/// The max pool layers function is to progressively reduce the spatial size of the representation
/// to reduce the amount of parameters and computation in the network.
/// The reduction is only done on the width and height. Depth dimension is preserved.
/// </summary>
/// <param name="poolWidth">The width of the pool area (default is 2)</param>
/// <param name="poolHeight">The height of the pool area (default is 2)</param>
/// <param name="stride">Controls the distance between each neighbouring pool areas (default is 2)</param>
/// <param name="borderMode">Border mode of the max pool operation.
/// This will set the width and height padding automatically based on the selected border mode: Valid, Same or Full (default is Valid).</param>
public MaxPool2DLayer(int poolWidth, int poolHeight, int stride = 2, BorderMode borderMode = BorderMode.Valid)
: this(poolWidth, poolHeight, stride,
ConvUtils.PaddingFromBorderMode(poolWidth, borderMode),
ConvUtils.PaddingFromBorderMode(poolHeight, borderMode))
{
BorderMode = borderMode;
}
/// <summary>
/// 2D Convolutional layer using GEMM implementation
/// based on: https://petewarden.com/2015/04/20/why-gemm-is-at-the-heart-of-deep-learning/
/// and: https://arxiv.org/pdf/1410.0759.pdf
/// </summary>
/// <param name="filterWidth">The width of the filters</param>
/// <param name="filterHeight">The height of the filters</param>
/// <param name="filterCount">The number of filters</param>
/// <param name="stride">Controls the distance between each neighbouring filter (default is 1)</param>
/// <param name="borderMode">Border mode of the convolutional operation.
/// This will set the width and height padding automatically based on the selected border mode: Valid, Same or Full (default is Valid)</param>
/// <param name="activation">Type of activation function used (default is Relu)</param>
public Conv2DLayer(int filterWidth, int filterHeight, int filterCount, int stride = 1,
BorderMode borderMode = BorderMode.Valid, Activation activation = Activation.Relu)
: this(filterWidth, filterHeight, filterCount, stride,
ConvUtils.PaddingFromBorderMode(filterWidth, borderMode),
ConvUtils.PaddingFromBorderMode(filterHeight, borderMode))
{
BorderMode = borderMode;
}
/// <summary>
///
/// </summary>
public CPanelPlus() : base()
{
InitializeComponent();
this.borderMode = BorderMode.None;
this.borderColor = Color.Black;
this.border3DStyle = System.Windows.Forms.Border3DStyle.Etched;
this.borderSide = ToolStripStatusLabelBorderSides.All;
}
protected void ComputeObstacles(CommandBuffer cmd, RenderTexture obstacles, BorderMode borderMode)
{
cmd.BeginSample("ComputeObstacles");
cmd.SetComputeTextureParam(computeShader, SetObstaclesKernel, "_Obstacles", obstacles);
cmd.SetComputeFloatParam(computeShader, "_BorderMode", (int)borderMode);
DispatchCompute(cmd, SetObstaclesKernel, (int)size.x, (int)size.y, (int)size.z);
cmd.EndSample("ComputeObstacles");
}
void CalculateSpriteBased(Sprite sprite, BorderMode borderMode)
{
var lastSprite = _lastUsedSprite;
_lastUsedSprite = sprite;
var spriteErrors = Diagnostics.CheckSprite(sprite);
if (spriteErrors != Errors.NoError)
{
if (lastSprite != sprite)
{
WarnSpriteErrors(spriteErrors);
}
CalculateSolidFill();
return;
}
if (!sprite)
{
CalculateSolidFill();
return;
}
FillCommonParameters();
var spriteRect = Mathr.Move(Mathr.ToVector(sprite.rect), sprite.textureRect.position - sprite.rect.position - sprite.textureRectOffset);
var textureRect = Mathr.ToVector(sprite.textureRect);
var textureBorder = Mathr.BorderOf(spriteRect, textureRect);
var textureSize = Vector2.zero;
if (sprite.texture != null)
{
textureSize = new Vector2(sprite.texture.width, sprite.texture.height);
}
var fullMaskRect = LocalMaskRect(Vector4.zero);
_parameters.maskRectUV = Mathr.Div(textureRect, textureSize);
if (borderMode == BorderMode.Simple)
{
var textureRectInFullRect = Mathr.Div(textureBorder, Mathr.Size(spriteRect));
_parameters.maskRect = Mathr.ApplyBorder(fullMaskRect, Mathr.Mul(textureRectInFullRect, Mathr.Size(fullMaskRect)));
}
else
{
_parameters.maskRect = Mathr.ApplyBorder(fullMaskRect, textureBorder * GraphicToCanvasScale(sprite));
var fullMaskRectUV = Mathr.Div(spriteRect, textureSize);
var adjustedBorder = AdjustBorders(sprite.border * GraphicToCanvasScale(sprite), fullMaskRect);
_parameters.maskBorder = LocalMaskRect(adjustedBorder);
_parameters.maskBorderUV = Mathr.ApplyBorder(fullMaskRectUV, Mathr.Div(sprite.border, textureSize));
}
_parameters.texture = sprite.texture;
_parameters.borderMode = borderMode;
if (borderMode == BorderMode.Tiled)
{
_parameters.tileRepeat = MaskRepeat(sprite, _parameters.maskBorder);
}
}
void Start()
{
try
{
dm = GameObject.Find("DispensaryManager").GetComponent <DispensaryManager>();
borderMode = BorderMode.activeOnUI;
}
catch (NullReferenceException)
{
// do nothing
}
}
/// <summary>
/// Gets the filter grid width based on input length, filter size, stride and padding.
/// </summary>
/// <param name="inputLength"></param>
/// <param name="filterSize"></param>
/// <param name="stride"></param>
/// <param name="padding"></param>
/// <param name="borderMode"></param>
/// <returns></returns>
public static int GetFilterGridLength(int inputLength, int filterSize,
int stride, int padding, BorderMode borderMode)
{
// BorderMode.Same pads with half the filter size on both sides (one less on
// the second side for an even filter size)
if ((borderMode == BorderMode.Same) && ((filterSize % 2) == 0))
{
return((int)Math.Floor((((inputLength + ((padding + padding) - 1)) - filterSize) / (double)stride) + 1));
}
return((int)Math.Floor((((inputLength + (padding * 2)) - filterSize) / (double)stride) + 1));
}
/// <summary>
///
/// </summary>
/// <param name="data_im"></param>
/// <param name="channels"></param>
/// <param name="height"></param>
/// <param name="width"></param>
/// <param name="kernel_h"></param>
/// <param name="kernel_w"></param>
/// <param name="pad_h"></param>
/// <param name="pad_w"></param>
/// <param name="stride_h"></param>
/// <param name="stride_w"></param>
/// <param name="borderMode"></param>
/// <param name="data_col"></param>
public static void Batch_Im2Col(Matrix <float> data_im, int channels, int height, int width,
int kernel_h, int kernel_w, int pad_h, int pad_w, int stride_h, int stride_w,
BorderMode borderMode, Matrix <float> data_col)
{
int height_col = GetFilterGridLength(height, kernel_h, stride_h, pad_h, borderMode);
int width_col = GetFilterGridLength(width, kernel_w, stride_w, pad_w, borderMode);
var batchSize = data_im.RowCount;
int channels_col = channels * kernel_h * kernel_w;
var data_imData = data_im.Data();
var data_colData = data_col.Data();
Parallel.For(0, batchSize, batchItem =>
{
var batchRowOffSet = batchItem * width_col * height_col;
for (int c = 0; c < channels_col; ++c)
{
int w_offset = c % kernel_w;
int h_offset = (c / kernel_w) % kernel_h;
int c_im = c / kernel_h / kernel_w;
var cImRowOffSet = c_im * height;
for (int h = 0; h < height_col; ++h)
{
var rowOffSet = h * width_col;
for (int w = 0; w < width_col; ++w)
{
int h_pad = ((h * stride_h) - pad_h) + h_offset;
int w_pad = ((w * stride_w) - pad_w) + w_offset;
var outColIndex = batchRowOffSet + rowOffSet + w;
var outputIndex = (outColIndex * data_col.RowCount) + c;
var inputColIndex = ((cImRowOffSet + h_pad) * width) + w_pad;
var inputIndex = (inputColIndex * batchSize) + batchItem;
if ((h_pad >= 0) && (h_pad < height) && (w_pad >= 0) && (w_pad < width))
{
data_colData[outputIndex] = data_imData[inputIndex];
}
else
{
data_colData[outputIndex] = 0;
}
}
}
}
});
}
public I <T> AddBorder(int top, int left, int bottom, int right, BorderMode mode = BorderMode.Zero)
{
var r = PadZero(top, left, bottom, right);
switch (mode)
{
case BorderMode.Replicate:
r.FillBorderReplicate(top, left, bottom, right);
break;
case BorderMode.Reflect:
r.FillBorderReflect(top, left, bottom, right);
break;
}
return(r);
}
void CalculateSpriteBased(Sprite sprite, BorderMode borderMode)
{
var lastSprite = _lastUsedSprite;
_lastUsedSprite = sprite;
var spriteErrors = Diagnostics.CheckSprite(sprite);
if (spriteErrors != Errors.NoError)
{
if (lastSprite != sprite)
{
WarnSpriteErrors(spriteErrors);
}
CalculateSolidFill();
return;
}
if (!sprite)
{
CalculateSolidFill();
return;
}
FillCommonParameters();
var inner = DataUtility.GetInnerUV(sprite);
var outer = DataUtility.GetOuterUV(sprite);
var padding = DataUtility.GetPadding(sprite);
var fullMaskRect = LocalMaskRect(Vector4.zero);
_parameters.maskRectUV = outer;
if (borderMode == BorderMode.Simple)
{
var normalizedPadding = Mathr.Div(padding, sprite.rect.size);
_parameters.maskRect = Mathr.ApplyBorder(fullMaskRect, Mathr.Mul(normalizedPadding, Mathr.Size(fullMaskRect)));
}
else
{
_parameters.maskRect = Mathr.ApplyBorder(fullMaskRect, padding * SpriteToCanvasScale(sprite));
var adjustedBorder = AdjustBorders(sprite.border * SpriteToCanvasScale(sprite), fullMaskRect);
_parameters.maskBorder = LocalMaskRect(adjustedBorder);
_parameters.maskBorderUV = inner;
}
_parameters.texture = sprite.texture;
_parameters.borderMode = borderMode;
if (borderMode == BorderMode.Tiled)
{
_parameters.tileRepeat = MaskRepeat(sprite, _parameters.maskBorder);
}
}
/// <summary>
///
/// </summary>
/// <param name="data_col"></param>
/// <param name="channels"></param>
/// <param name="height"></param>
/// <param name="width"></param>
/// <param name="patch_h"></param>
/// <param name="patch_w"></param>
/// <param name="pad_h"></param>
/// <param name="pad_w"></param>
/// <param name="stride_h"></param>
/// <param name="stride_w"></param>
/// <param name="borderMode"></param>
/// <param name="data_im"></param>
public static void Batch_Col2Im(Matrix <float> data_col, int channels, int height, int width,
int patch_h, int patch_w, int pad_h, int pad_w, int stride_h, int stride_w,
BorderMode borderMode, Matrix <float> data_im)
{
int height_col = GetFilterGridLength(height, patch_h, stride_h, pad_h, borderMode);
int width_col = GetFilterGridLength(width, patch_w, stride_w, pad_w, borderMode);
int channels_col = channels * patch_h * patch_w;
var batchSize = data_im.RowCount;
var data_colData = data_col.Data();
var data_imData = data_im.Data();
Parallel.For(0, batchSize, batchItem =>
{
var batchRowOffSet = batchItem * width_col * height_col;
for (int c = 0; c < channels_col; ++c)
{
int w_offset = c % patch_w;
int h_offset = (c / patch_w) % patch_h;
int c_im = c / patch_h / patch_w;
var c_ImRowOffSet = c_im * height;
for (int h = 0; h < height_col; ++h)
{
var rowOffSet = h * width_col;
int h_pad = ((h * stride_h) - pad_h) + h_offset;
for (int w = 0; w < width_col; ++w)
{
int w_pad = ((w * stride_w) - pad_w) + w_offset;
if ((h_pad >= 0) && (h_pad < height) && (w_pad >= 0) && (w_pad < width))
{
var colColIndex = batchRowOffSet + rowOffSet + w;
var outIndex = ((c_ImRowOffSet + h_pad) * width) + w_pad;
var imIndex = (outIndex * batchSize) + batchItem;
var colIndex = (colColIndex * data_col.RowCount) + c;
var newValue = data_imData[imIndex] + data_colData[colIndex];
data_imData[imIndex] = newValue;
}
}
}
}
});
}
private void TransformAlign(float positionValue, BorderMode borderMode, Orientation orientation)
{
// History
LayersTransformAddHistory history = new LayersTransformAddHistory(HistoryType.LayersTransformAdd_Move);
// Selection
this.SelectionViewModel.SetValue((layerage) =>
{
Transformer transformer = layerage.GetActualTransformer();
float value = transformer.GetBorderValue(borderMode);
float distance = positionValue - value;
if (distance == 0)
{
return;
}
Vector2 vector = orientation == Orientation.Horizontal ?
new Vector2(distance, 0) :
new Vector2(0, distance);
layerage.SetValueWithChildren((layerage2) =>
{
ILayer layer = layerage2.Self;
// History
history.PushTransform(layer, vector);
// Refactoring
layer.IsRefactoringTransformer = true;
layer.IsRefactoringRender = true;
layer.IsRefactoringIconRender = true;
layerage.RefactoringParentsTransformer();
layerage.RefactoringParentsRender();
layerage.RefactoringParentsIconRender();
layer.CacheTransform();
layer.TransformAdd(vector);
});
});
// Refactoring
this.SelectionViewModel.Transformer = this.SelectionViewModel.RefactoringTransformer();
// History
this.ViewModel.HistoryPush(history);
this.ViewModel.Invalidate(); // Invalidate}
}
/// <summary>
/// Gets value by left, right, top, bottom.
/// </summary>
/// <param name="borderMode"> The border mode </param>
/// <returns> The produced value. </returns>
public float GetBorderValue(BorderMode borderMode)
{
switch (borderMode)
{
case BorderMode.MinX: return(0);
case BorderMode.CenterX: return(this.Width / 2.0f);
case BorderMode.MaxX: return(this.Width);
case BorderMode.MinY: return(0);
case BorderMode.CenterY: return(this.Height / 2.0f);
case BorderMode.MaxY: return(this.Height);
}
return(0);
}
/// <summary>
/// Gets value by left, right, top, bottom.
/// </summary>
/// <param name="borderMode"> The border mode </param>
/// <returns> The produced value. </returns>
public float GetBorderValue(BorderMode borderMode)
{
switch (borderMode)
{
case BorderMode.MinX: return(this.MinX);
case BorderMode.CenterX: return(this.Center.X);
case BorderMode.MaxX: return(this.MaxX);
case BorderMode.MinY: return(this.MinY);
case BorderMode.CenterY: return(this.Center.Y);
case BorderMode.MaxY: return(this.MaxY);
}
return(this.MinX);
}
/// <summary>
/// Gets value by left, right, top, bottom.
/// </summary>
/// <param name="borderMode"> The border mode </param>
/// <returns> The produced value. </returns>
public float GetBorderValue(BorderMode borderMode)
{
switch (borderMode)
{
case BorderMode.MinX: return(this.Left);
case BorderMode.CenterX: return(this.CenterX);
case BorderMode.MaxX: return(this.Right);
case BorderMode.MinY: return(this.Top);
case BorderMode.CenterY: return(this.CenterY);
case BorderMode.MaxY: return(this.Bottom);
}
return(this.Left);
}
private void TransformAlign(BorderMode borderMode, Orientation orientation)
{
switch (this.Mode)
{
case ListViewSelectionMode.Single:
{
float positionValue = this.ViewModel.CanvasTransformer.GetBorderValue(borderMode);
this.TransformAlign(positionValue, borderMode, orientation);
}
break;
case ListViewSelectionMode.Multiple:
{
Transformer transformer = this.Transformer;
float positionValue = transformer.GetBorderValue(borderMode);
this.TransformAlign(positionValue, borderMode, orientation);
}
break;
}
}
public static void warpAffine(Mat src, Mat dst, System.Numerics.Matrix3x2 trans, Size dSize,
Interpolation inter = Interpolation.INTER_LINEAR, bool inverseMap = false,
BorderMode borderMode = BorderMode.BORDER_CONSTANT, double[] borderValue = null)
{
Mat transMat = trans;
int flags = inverseMap ? ((int)InverseMap.WARP_INVERSE_MAP | (int)inter) : (int)inter;
Mat matBorderValue = null;
IntPtr ptrBorderValue = IntPtr.Zero;
if (borderMode == BorderMode.BORDER_CONSTANT && borderValue != null && borderValue.Length > 0)
{
matBorderValue = new Mat(1, borderValue.Length, Mat.makeType(1, Mat.MatDepth.CV_64F));
if (matBorderValue.Valid && matBorderValue.copyAll(borderValue, 0, borderValue.Length))
{
ptrBorderValue = matBorderValue.Data;
}
}
NativeInvoker.coreCvWarpAffine(src.MatObj, dst.MatObj, transMat.MatObj, (int)dSize.w, (int)dSize.h,
flags, (int)borderMode, ptrBorderValue);
}
/// <summary>
///
/// </summary>
/// <param name="filterSize"></param>
/// <param name="borderMode"></param>
/// <returns></returns>
public static int PaddingFromBorderMode(int filterSize, BorderMode borderMode)
{
switch (borderMode)
{
case BorderMode.Same:
return(filterSize / 2);
case BorderMode.Valid:
return(0);
case BorderMode.Full:
return(filterSize - 1);
case BorderMode.Undefined:
return(0);
default:
throw new ArgumentException("Unsupported border mode: " + borderMode);
}
}
// 0 = Green
// 1 = Red
// 2 = Yellow/Orange
public void ChangeColor(int index)
{
switch (index)
{
case 0:
screenborder.sprite = SpriteManager.screenborder_Green;
borderMode = BorderMode.activeOnUI;
break;
case 1:
screenborder.sprite = SpriteManager.screenborder_Red;
borderMode = BorderMode.alwaysActive;
break;
case 2:
screenborder.sprite = SpriteManager.screenborder_Yellow;
borderMode = BorderMode.alwaysActive;
break;
}
}
/// <summary>
/// 2D Convolutional layer using GEMM implementation
/// based on: https://petewarden.com/2015/04/20/why-gemm-is-at-the-heart-of-deep-learning/
/// and: https://arxiv.org/pdf/1410.0759.pdf
/// </summary>
/// <param name="filterWidth">The width of the filters</param>
/// <param name="filterHeight">The height of the filters</param>
/// <param name="filterCount">The number of filters</param>
/// <param name="stride">Controls the distance between each neighbouring filter (default is 1)</param>
/// <param name="padWidth">Zero padding for the width dimension (default is 0)</param>
/// <param name="padHeight">Zero padding for the height dimension (default is 0)</param>
/// <param name="activation">Type of activation function used (default is Relu)</param>
public Conv2DLayer(int filterWidth, int filterHeight, int filterCount, int stride,
int padWidth, int padHeight, Activation activation = Activation.Relu)
{
if (filterWidth < 1)
{
throw new ArgumentException("filterWidth is less than 1: " + filterWidth);
}
if (filterHeight < 1)
{
throw new ArgumentException("poolHeight is less than 1: " + filterHeight);
}
if (filterCount < 1)
{
throw new ArgumentException("filterCount is less than 1: " + filterCount);
}
if (padWidth < 0)
{
throw new ArgumentException("padWidth is less than 0: " + padWidth);
}
if (padHeight < 0)
{
throw new ArgumentException("padHeight is less than 0: " + padHeight);
}
if (stride < 1)
{
throw new ArgumentException("stride is less than 0: " + stride);
}
FilterWidth = filterWidth;
FilterHeight = filterHeight;
FilterCount = filterCount;
ActivationFunc = activation;
m_stride = stride;
m_padWidth = padWidth;
m_padHeight = padHeight;
BorderMode = BorderMode.Undefined;
}
/// <summary>
///
/// </summary>
/// <param name="data_convolutedRowMajor"></param>
/// <param name="channels"></param>
/// <param name="height"></param>
/// <param name="width"></param>
/// <param name="kernel_h"></param>
/// <param name="kernel_w"></param>
/// <param name="pad_h"></param>
/// <param name="pad_w"></param>
/// <param name="stride_h"></param>
/// <param name="stride_w"></param>
/// <param name="borderMode"></param>
/// <param name="convoluted"></param>
public static void ReshapeRowMajorToConvolutionLayout(Matrix <float> data_convolutedRowMajor,
int channels, int height, int width,
int kernel_h, int kernel_w, int pad_h, int pad_w, int stride_h, int stride_w,
BorderMode borderMode, Matrix <float> convoluted)
{
int height_col = GetFilterGridLength(height, kernel_h, stride_h, pad_h, borderMode);
int width_col = GetFilterGridLength(width, kernel_w, stride_w, pad_w, borderMode);
var columnWidth = height_col * width_col;
var filterCount = convoluted.RowCount;
var batchSize = data_convolutedRowMajor.RowCount;
var convolutedData = convoluted.Data();
var data_convolutedRowMajorData = data_convolutedRowMajor.Data();
Parallel.For(0, batchSize, batchItem =>
{
var batchOffSet = batchItem * columnWidth;
for (int filter = 0; filter < filterCount; filter++)
{
var rowOffSet = filter * columnWidth;
for (int column = 0; column < columnWidth; column++)
{
// get value from row major data
var rowMajorIndex = rowOffSet + column;
var index = (rowMajorIndex * batchSize) + batchItem;
var rowValue = data_convolutedRowMajorData[index];
// set value in conv data
var convIndex = ((batchOffSet + column) * filterCount) + filter;
convolutedData[convIndex] = rowValue;
}
}
});
}
public void CopyFromLerped(RectStyle a, RectStyle b, float t)
{
color = Color.Lerp(a.color, b.color, t);
if ((a.gradient?.keyPointCount ?? 0) != (b.gradient?.keyPointCount ?? 0))
{
// TODO
}
else if (a.gradient != null && b.gradient != null && a.gradient.keyPointCount > 0)
{
gradientAngle = Mathf.LerpAngle(a.gradientAngle, b.gradientAngle, t);
if (gradient == null)
{
gradient = new Gradient();
}
else
{
gradient.Clear();
}
for (var i = 0; i < a.gradient.keyPointCount; ++i)
{
gradient.Add(new GradientKeyPoint
{
color = Color.Lerp(a.gradient[i].color, b.gradient[i].color, t),
progress = Mathf.Lerp(a.gradient[i].progress, b.gradient[i].progress, t)
});
}
}
enableGradient = a.enableGradient || b.enableGradient;
borderMode = a.borderMode | b.borderMode;
borderColor = a.HasBorder != b.HasBorder
? a.HasBorder
? a.borderColor
: b.borderColor
: Color.Lerp(a.borderColor, b.borderColor, t);
borderWidth = Mathf.Lerp(a.HasBorder ? a.borderWidth : 0f, b.HasBorder ? b.borderWidth : 0f, t);
cornerRadius = Mathf.Lerp(a.cornerRadius, b.cornerRadius, t);
var boxShadowColorA = a.enableBoxShadow ? a.boxShadowColor : b.boxShadowColor;
var boxShadowColorB = b.enableBoxShadow ? b.boxShadowColor : a.boxShadowColor;
if (!a.enableBoxShadow)
{
boxShadowColorA.a = 0f;
}
if (!b.enableBoxShadow)
{
boxShadowColorB.a = 0f;
}
enableBoxShadow = a.enableBoxShadow || b.enableBoxShadow;
boxShadowColor = Color.Lerp(boxShadowColorA, boxShadowColorB, t);
boxShadowBlurRadius = Mathf.Lerp(
a.enableBoxShadow ? a.boxShadowBlurRadius : b.boxShadowBlurRadius,
b.enableBoxShadow ? b.boxShadowBlurRadius : a.boxShadowBlurRadius, t);
boxShadowOffset = Vector2.Lerp(
a.enableBoxShadow ? a.boxShadowOffset : b.boxShadowOffset,
b.enableBoxShadow ? b.boxShadowOffset : a.boxShadowOffset, t);
boxShadowInner = Mathf.Lerp(
a.enableBoxShadow ? a.boxShadowInner : b.boxShadowInner,
b.enableBoxShadow ? b.boxShadowInner : a.boxShadowInner, t);
}
public bool SetCss(string css)
{
if (css == null)
{
return(true);
}
// Get rid of comments
css = _sCssComment.Replace(css, match => new string(match.Value
.Select(x => char.IsWhiteSpace(x) ? x : ' ')
.ToArray()));
var newColor = color;
var newEnableGradient = enableGradient;
var newGradient = new Gradient();
if (gradient != null)
{
foreach (var keyPoint in gradient)
{
newGradient.Add(keyPoint);
}
}
var newGradientAngle = gradientAngle;
var newBorderMode = borderMode;
var newBorderColor = borderColor;
var newBorderWidth = borderWidth;
var newCornerRadius = cornerRadius;
var valid = true;
var hasOpacity = false;
foreach (Match match in _sCssStatement.Matches(css))
{
var command = match.Groups["command"].Value;
var value = match.Groups["value"].Value;
switch (command)
{
case "background":
{
var colorMatch = _sCssColor.Match(value);
if (colorMatch.Success && colorMatch.Index == 0)
{
newColor = ParseColor(colorMatch, hasOpacity ? newColor.a : 1f);
newEnableGradient = false;
break;
}
var gradientMatch = _sCssLinearGradient.Match(value);
if (gradientMatch.Success && gradientMatch.Index == 0)
{
newColor = Color.white;
newGradientAngle = float.Parse(gradientMatch.Groups["angle"].Value);
newEnableGradient = true;
newGradient.Clear();
foreach (Capture capture in gradientMatch.Groups["point"].Captures)
{
var pointMatch = _sCssGradientPoint.Match(capture.Value);
newGradient.Add(new GradientKeyPoint
{
color = ParseColor(pointMatch.Groups["color"].Value),
progress = pointMatch.Groups["percent"].Success
? float.Parse(pointMatch.Groups["percent"].Value) / 100f : 0f
});
}
break;
}
valid = false;
break;
}
case "opacity":
{
float opacity;
if (float.TryParse(value, out opacity))
{
newColor.a = opacity;
hasOpacity = true;
break;
}
valid = false;
break;
}
case "border":
{
var borderMatch = _sCssBorder.Match(value);
if (borderMatch.Success && borderMatch.Index == 0)
{
newBorderMode = BorderMode.All;
newBorderColor = ParseColor(borderMatch.Groups["color"].Value);
newBorderWidth = ParsePixels(borderMatch.Groups["width"].Value);
valid = true;
break;
}
valid = false;
break;
}
case "border-radius":
{
var pixelsMatch = _sCssPixels.Match(value);
if (pixelsMatch.Success && pixelsMatch.Index == 0)
{
newCornerRadius = ParsePixels(pixelsMatch.Value);
valid = true;
break;
}
valid = false;
break;
}
}
}
if (valid)
{
color = newColor;
enableGradient = newEnableGradient;
gradientAngle = newGradientAngle;
borderMode = newBorderMode;
borderColor = newBorderColor;
borderWidth = newBorderWidth;
cornerRadius = newCornerRadius;
gradient = newGradient;
}
return(valid);
}
