public void SetCornerTypeFromString(string name)
{
switch (name)
{
case "Red":
cornerType = CornerType.Red;
break;
case "Green":
cornerType = CornerType.Green;
break;
case "Blue":
cornerType = CornerType.Blue;
break;
case "Purple":
cornerType = CornerType.Purple;
break;
default:
cornerType = CornerType.Red;
break;
}
AssignOffset();
SetSandboxAsChild();
}
public CornerShape(CornerType type)
{
topLeft = type;
topRight = type;
bottomLeft = type;
bottomRight = type;
}
//Color edges an RGBA
public void EdgeCorners(GridContext bgc, byte ri, byte gi, byte bi, byte ai)
{
if (bgc == null)
{
return;
}
Grid grid = bgc.Grid;
//Inhibit because it would affect ALL drawn pixels
grid.InhibitCodeTracking();
for (int z = 0; z < grid.SizeZ; z++)
{
for (int y = 0; y < grid.SizeY; y++)
{
for (int x = 0; x < grid.SizeX; x++)
{
ulong u = grid.GetRgba(x, y, z);
if (u > 0)
//if ((byte)grid.GetProperty(x, y, z).ShapeId != 0)
{
/* Logic for detecting smoothing is... (using 6-cell axis formation cells left/right/forward/back/top/bottom)
* Blue : 2 units nearby
* Red : 3 units nearby
* Green: 4 units nearby
*/
CornerType cornerType = CalculateShape(grid, x, y, z);
int shape = (int)cornerType;
grid.Plot(x, y, z, u, 0, (byte)shape, grid.GetProperty(x, y, z).TextureId, 0, 0);
}
}
}
}
grid.AllowCodeTracking();
}
public void Assign(CornerShape shape)
{
TopLeft = shape.topLeft;
TopRight = shape.topRight;
BottomLeft = shape.bottomLeft;
BottomRight = shape.bottomRight;
}
public CornerShape()
{
topLeft = CornerType.Round;
topRight = CornerType.Round;
bottomLeft = CornerType.Round;
bottomRight = CornerType.Round;
}
/// <summary>
/// Initializes a new instance of <see cref="CornerShape"/>
/// </summary>
public CornerShape()
{
topLeft = CornerType.Round;
topRight = CornerType.Round;
bottomLeft = CornerType.Round;
bottomRight = CornerType.Round;
}
/// <summary>
/// Initializes a new instance of <see cref="CornerShape"/>
/// </summary>
/// <param name="type"><see cref="CornerType"/> for all corners.</param>
public CornerShape(CornerType type)
{
topLeft = type;
topRight = type;
bottomLeft = type;
bottomRight = type;
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
public void ReadXml(XmlReader reader)
{
var doc = new XmlDocument();
doc.Load(reader);
if (doc.GetElementsByTagName("BottomLeft").Count > 0)
{
BottomLeft =
(CornerType)Enum.Parse(typeof(CornerType), doc.GetElementsByTagName("BottomLeft")[0].InnerText);
}
if (doc.GetElementsByTagName("BottomRight").Count > 0)
{
BottomRight =
(CornerType)Enum.Parse(typeof(CornerType), doc.GetElementsByTagName("BottomRight")[0].InnerText);
}
if (doc.GetElementsByTagName("TopLeft").Count > 0)
{
TopLeft = (CornerType)Enum.Parse(typeof(CornerType), doc.GetElementsByTagName("TopLeft")[0].InnerText);
}
if (doc.GetElementsByTagName("TopRight").Count > 0)
{
TopRight =
(CornerType)Enum.Parse(typeof(CornerType), doc.GetElementsByTagName("TopRight")[0].InnerText);
}
}
public RoundedCornersTransformation(int radius, int margin, CornerType cornerType)
{
_radius = radius;
_diameter = radius * 2;
_margin = margin;
_cornerType = cornerType;
}
//Color edges an RGBA
public void ShapeSmoothX(GridContext bgc)
{
if (bgc == null)
{
return;
}
Grid grid = bgc.Grid;
//Inhibit because it would affect ALL drawn pixels
grid.InhibitCodeTracking();
for (int z = 0; z < grid.SizeZ; z++)
{
for (int y = 0; y < grid.SizeY; y++)
{
for (int x = 0; x < grid.SizeX; x++)
{
ulong u = grid.GetRgba(x, y, z);
if (u > 0)
{
CornerType cornerType = CalculateShapeX(grid, x, y, z);
int shape = (int)cornerType;
grid.Plot(x, y, z, u, 0, (byte)shape, grid.GetProperty(x, y, z).TextureId, 0, 0);
}
}
}
}
grid.AllowCodeTracking();
}
private void HandleCorners(PlayerController player)
{
Vector3 desiredDirection = Mathf.Sign(right) * player.transform.right;
CornerType moveType = CheckCorner(player, desiredDirection);
if (moveType == CornerType.Out)
{
player.UseRootMotion = false;
isOutCornering = true;
}
else if (moveType == CornerType.In)
{
player.UseRootMotion = false;
isInCornering = true;
}
else if (moveType == CornerType.Stop)
{
right = 0f;
player.UseRootMotion = false;
}
else
{
player.UseRootMotion = true;
}
player.Anim.SetBool("isOutCorner", isOutCornering);
player.Anim.SetBool("isInCorner", isInCornering);
}
public static HexPoint HexCorner(float size, CornerType cornerType)
{
var innerSize = OuterToInner(size);
var halfSize = size * 0.5f;
var offset = new HexPoint(0, 0, 0);
switch (cornerType)
{
case CornerType.Corner1:
offset = new HexPoint(innerSize, -halfSize, 0);
break;
case CornerType.Corner2:
offset = new HexPoint(0, -size, 0);
break;
case CornerType.Corner3:
offset = new HexPoint(-innerSize, -halfSize, 0);
break;
case CornerType.Corner4:
offset = new HexPoint(-innerSize, halfSize, 0);
break;
case CornerType.Corner5:
offset = new HexPoint(0, size, 0);
break;
case CornerType.Corner6:
offset = new HexPoint(innerSize, halfSize, 0);
break;
}
return(offset);
}
public static Vector3 GetCorner(this Bounds bounds, CornerType type)
{
var center = bounds.center;
var extents = bounds.extents;
switch (type)
{
default:
case CornerType.LeftDownBackward:
return(center - extents);
case CornerType.RightUpForward:
return(center + extents);
case CornerType.LeftDownForward:
return(center + new Vector3(-extents.x, -extents.y, extents.z));
case CornerType.LeftUpBackward:
return(center + new Vector3(-extents.x, extents.y, -extents.z));
case CornerType.LeftUpForward:
return(center + new Vector3(-extents.x, extents.y, extents.z));
case CornerType.RightDownBackward:
return(center + new Vector3(extents.x, -extents.y, -extents.z));
case CornerType.RightUpBackward:
return(center + new Vector3(extents.x, extents.y, -extents.z));
case CornerType.RightDownForward:
return(center + new Vector3(extents.x, -extents.y, extents.z));
}
}
public void MoveToDefendingCornerPosition(CornerType corner)
{
int angle = 90;
float x = DefendingCornerPosition.x;
float y = DefendingCornerPosition.y;
switch (corner)
{
case CornerType.LowerLeft:
{
y = -y;
}
break;
case CornerType.UpperRight:
{
angle = 270;
x = -x;
}
break;
case CornerType.LowerRight:
{
angle = 270;
x = -x;
y = -y;
}
break;
}
MoveTo(x, y, angle);
}
public static PointF GetCornerPoint(this RectangleF rect, CornerType type)
{
switch (type)
{
case CornerType.LeftTop:
return(rect.Location);
case CornerType.LeftMiddle:
return(new PointF(rect.X, rect.Y + rect.Height / 2));
case CornerType.LeftBottom:
return(new PointF(rect.X, rect.Bottom));
case CornerType.Top:
return(new PointF(rect.X + rect.Width / 2, rect.Y));
case CornerType.Bottom:
return(new PointF(rect.X + rect.Width / 2, rect.Bottom));
case CornerType.RightTop:
return(new PointF(rect.Right, rect.Y));
case CornerType.RightMiddle:
return(new PointF(rect.Right, rect.Y + rect.Height / 2));
case CornerType.RightBottom:
return(new PointF(rect.Right, rect.Bottom));
case CornerType.Center:
return(rect.Location + new SizeF(rect.Width / 2, rect.Height / 2));
default:
return(PointF.Empty);
}
}
private static Shape GenerateRoundedCorner(CornerType type)
{
float[] verts = new float[92 * 3];
float rotOffset = 0;
float xOffset = 0;
float yOffset = 0;
switch (type)
{
case CornerType.TopLeft:
rotOffset = (float)Math.PI;
xOffset = 1;
yOffset = 1;
break;
case CornerType.TopRight:
rotOffset = (float)(Math.PI / 2) * 3;
xOffset = 0;
yOffset = 1;
break;
case CornerType.BottomLeft:
rotOffset = (float)(Math.PI / 2);
xOffset = 1;
break;
case CornerType.BottomRight:
rotOffset = 0;
break;
}
for (int i = 0; i < 91; i++)
{
float degInRad = MathHelper.DegreesToRadians(i);
float x = ((float)Math.Cos(degInRad + rotOffset)) + xOffset;
float y = ((float)Math.Sin(degInRad + rotOffset)) + yOffset;
verts[i * 3] = x;
verts[(i * 3) + 1] = y;
verts[(i * 3) + 2] = 0f;
}
Vector3 corner = new Vector3(-0.5f, -0.5f, 0f);
corner = Vector3.TransformPosition(corner, Matrix4.CreateRotationZ(rotOffset));
corner.X += 0.5f;
corner.Y += 0.5f;
verts[(91 * 3)] = corner.X;
verts[(91 * 3) + 1] = corner.Y;
verts[(91 * 3) + 2] = 0f;
Shape shape = new Shape(verts);
return(shape);
}
public static void Draw(Rect rect, DColor dColor, CornerType cornerType = DEFAULT_CORNER_TYPE)
{
Color color = GUI.color;
GUI.color = Colors.BackgroundColor(dColor).WithAlpha(BACKGROUND_ALPHA * color.a);
GUI.Label(rect, GUIContent.none, Style(cornerType));
GUI.color = color;
}
public static void Draw(DColor dColor, CornerType cornerType, params GUILayoutOption[] options)
{
Color color = GUI.color;
GUI.color = Colors.BackgroundColor(dColor).WithAlpha(BACKGROUND_ALPHA * color.a);
GUILayout.Label(GUIContent.none, Style(cornerType), options);
GUI.color = color;
}
public Loft()
{
_StartCapping = CappingMode.Flat;
_EndCapping = CappingMode.Flat;
_Thickness = 1;
_ThickenDirection = Direction.Inwards;
_ThickenCornerType = CornerType.Round;
}
private CornerSprite GetCornerSprite(CornerType cornerType)
{
var cornerSprite = new CornerSprite();
cornerSprite.cornerType = cornerType;
cornerSprite.sprites = new List <Sprite>();
cornerSprite.sprites.Insert(0, null);
return(cornerSprite);
}
public override void Resize(CornerType type, PointF targetPoint, bool resizeFixRadio)
{
var rect = GetBounds().Resize(type, targetPoint, resizeFixRadio);
StringSize = new SizeF(rect.Width, rect.Height);
Location = rect.Location;
UpdateBound(rect.Location, rect.Width, rect.Height);
UpdateResizeHandle();
IsGraphicsPathChanged = true;
}
public static GUIStyle Style(CornerType type)
{
switch (type)
{
case CornerType.Round: return(Styles.GetStyle(Styles.StyleName.BackgroundRound));
case CornerType.Square: return(Styles.GetStyle(Styles.StyleName.BackgroundSquare));
default: throw new ArgumentOutOfRangeException("type", type, null);
}
}
public static void Draw(DColor dColor, CornerType cornerType, float height, params GUILayoutOption[] options)
{
var list = new List <GUILayoutOption>();
if (options != null)
{
list.AddRange(options);
}
list.Add(GUILayout.Height(height));
Draw(dColor, cornerType, list.ToArray());
}
/// <summary>
/// calculates values which are defined in the classes which inherits from TrackSegment according to the properties defined in TrackSegment
/// </summary>
protected override void CalculateDerivedValues()
{
//CornerType
//c_ = k*a_ + h*b_ = EndPoint-StartPoint
//if h>0 => right else left
Vector2 c = EndPoint - PreviousTrackSegment.EndPoint;
Vector2 a = PreviousTrackSegment.EndDirection;
Vector2 b = a.Normal();
if ((a.X * c.Y - c.X) / (b.Y * a.X - b.X - a.Y) > 0)
{
_type = CornerType.RightCorner;
}
else
{
_type = CornerType.LeftCorner;
}
if (EndPoint.Equals(PreviousTrackSegment.EndPoint)) //complete circle
{
Radius = (TrackWidthEnd + PreviousTrackSegment.TrackWidthEnd) / 2;
Angle = Convert.ToSingle(2 * Math.PI);
//set the radius to the middle radius of the trackwidth of this curve and the previous tracksegment
_middlePoint = PreviousTrackSegment.EndDirection.Normal().Normalize() * Radius +
PreviousTrackSegment.EndPoint;
}
else
{
//calculate middle point
//the middle point is where the normal vector of the vector between start and endpoint intercects with the normal vector of the starting direction
Vector2 connectingVector = (EndPoint - PreviousTrackSegment.EndPoint) / 2; //2 to get the middle of the distance
Vector2 normalVectorMiddle = connectingVector.Normal();
_middlePoint = normalVectorMiddle.GetIntersectionPoint(PreviousTrackSegment.EndDirection.Normal(),
PreviousTrackSegment.EndPoint, PreviousTrackSegment.EndPoint + connectingVector);
//calculate radius
_radius = (EndPoint - _middlePoint).Magnitude;
//calculate angle
if (Type == CornerType.LeftCorner)
{
_angle = normalVectorMiddle.GetEnclosedAngle(_endPoint - _middlePoint) * 2;
}
else
{
_angle = normalVectorMiddle.GetEnclosedAngle(_middlePoint - _endPoint) * 2;
}
}
CalculateStartingAngle();
}
private CornerView CreateCorner(CornerType type, string normalImageName, string selectedImageName)
{
CornerView cv = new CornerView(
new UIImage(normalImageName),
new UIImage(selectedImageName)
);
cv.CornerType = type;
corners[(uint)type] = cv;
AddSubview(cv);
return(cv);
}
private void Corner(CornerType corner, Team attackingTeam, Team defendingTeam)
{
Score.Corners[attackingTeam]++;
Ball.MoveToCorner(corner);
foreach (var p in Teams[attackingTeam])
{
p.MoveToAttackingCornerPosition(corner);
}
foreach (var p in Teams[defendingTeam])
{
p.MoveToDefendingCornerPosition(corner);
}
}
/// <summary>
/// 对已有的矩形做缩放
/// </summary>
/// <param name="rect">原始矩形</param>
/// <param name="type">操作类型，左上角、中段、右上角等</param>
/// <param name="p">当前光标位置</param>
/// <param name="resizeFixRadio">是否等比例</param>
/// <returns></returns>
public static RectangleF Resize(this RectangleF rect, CornerType type, PointF p, bool resizeFixRadio)
{
RectangleF result = Rectangle.Empty;
switch (type)
{
case CornerType.LeftTop:
result = ResizeByLeftTopHandle(rect, p, resizeFixRadio);
break;
case CornerType.LeftBottom:
result = ResizeByLeftBottomHandle(rect, p, resizeFixRadio);
break;
case CornerType.RightTop:
result = ResizeByRightTopHandle(rect, p, resizeFixRadio);
break;
case CornerType.RightBottom:
result = ResizeByRightBottom(rect, p, resizeFixRadio);
break;
case CornerType.LeftMiddle:
result = ResizeByLeftMiddleHandle(rect, p);
break;
case CornerType.Top:
result = ResizeByTopHandle(rect, p);
break;
case CornerType.Bottom:
result = ResizeByBottomHandle(rect, p);
break;
case CornerType.RightMiddle:
result = ResizeByRightMiddleBottom(rect, p);
break;
case CornerType.Center:
default:
break;
}
return(result);
}
public override bool OnHitTest(SKPoint location, long fingerId)
{
SKPoint hitPoint = GetNewCoordinatedPoint(location);
//左上角
SKRect rect = SKRect.Create(_cropRect.Left - _cornerTouchRadius, _cropRect.Top - _cornerTouchRadius, _cornerTouchRadius * 2, _cornerTouchRadius * 2);
if (rect.Contains(hitPoint))
{
_hittedCorner = CornerType.LeftTop;
return(true);
}
//右上角
rect = SKRect.Create(_cropRect.Right - _cornerTouchRadius, _cropRect.Top - _cornerTouchRadius, _cornerTouchRadius * 2, _cornerTouchRadius * 2);
if (rect.Contains(hitPoint))
{
_hittedCorner = CornerType.RightTop;
return(true);
}
//左下角
rect = SKRect.Create(_cropRect.Left - _cornerTouchRadius, _cropRect.Bottom - _cornerTouchRadius, _cornerTouchRadius * 2, _cornerTouchRadius * 2);
if (rect.Contains(hitPoint))
{
_hittedCorner = CornerType.LeftBottom;
return(true);
}
//右下角
rect = SKRect.Create(_cropRect.Right - _cornerTouchRadius, _cropRect.Bottom - _cornerTouchRadius, _cornerTouchRadius * 2, _cornerTouchRadius * 2);
if (rect.Contains(hitPoint))
{
_hittedCorner = CornerType.RightBottom;
return(true);
}
_hittedCorner = CornerType.None;
return(false);
}
public void MoveToCorner(CornerType corner)
{
if (corner == CornerType.UpperLeft)
{
MoveTo(-3.7f, 2.7f);
}
else if (corner == CornerType.LowerLeft)
{
MoveTo(-3.7f, -2.7f);
}
else if (corner == CornerType.UpperRight)
{
MoveTo(3.7f, 2.7f);
}
else if (corner == CornerType.LowerRight)
{
MoveTo(3.7f, -2.7f);
}
}
private void GenerateCorner(CornerType corner, int amountPerLine)
{
if (corner == CornerType.downLeft)
{
GenerateTreesAtPos(amountPerLine, -0.5f, 0.5f, 0.0f, 0.5f); // horizontal
GenerateTreesAtPos(amountPerLine, 0.0f, 0.5f, -0.5f, 0.5f); // vertical
}
else if (corner == CornerType.downRight)
{
GenerateTreesAtPos(amountPerLine, -0.5f, 0.5f, 0.0f, 0.5f); // horizontal
GenerateTreesAtPos(amountPerLine, -0.5f, 0.0f, -0.5f, 0.5f); // vertical
}
else if (corner == CornerType.upLeft)
{
GenerateTreesAtPos(amountPerLine, -0.5f, 0.5f, -0.5f, 0.0f); // horizontal
GenerateTreesAtPos(amountPerLine, 0.0f, 0.5f, -0.5f, 0.5f); // vertical
}
else if (corner == CornerType.upRight)
{
GenerateTreesAtPos(amountPerLine, -0.5f, 0.5f, -0.5f, 0.0f); // horizontal
GenerateTreesAtPos(amountPerLine, -0.5f, 0.0f, -0.5f, 0.5f); // vertical
}
}
/// <summary>
/// returns the 3 corners adjacent to the input corner
/// </summary>
/// 
public static List <Vector3Int> AdjacentToCorner(Vector3Int corner)
{
Vector3Int a, b, c;
CornerType cornerType = HexUtility.GetCornerType(corner);
//its the same approach like getting adjacent tiles but inverted (and without dividing by 3)
if (cornerType == CornerType.BottomOfYParallelEdge)
{
a = new Vector3Int((corner.x - 1), (corner.y + 2), (corner.z - 1));
b = new Vector3Int((corner.x + 2), (corner.y - 1), (corner.z - 1));
c = new Vector3Int((corner.x - 1), (corner.y - 1), (corner.z + 2));
}
else
{
a = new Vector3Int((corner.x + 1), (corner.y + 1), (corner.z - 2));
b = new Vector3Int((corner.x + 1), (corner.y - 2), (corner.z + 1));
c = new Vector3Int((corner.x - 2), (corner.y + 1), (corner.z + 1));
}
return(new List <Vector3Int> {
a, b, c
});
}
void ChangeCornerPosition(CornerType type, int x, int y)
{
if (type == CornerType.LeftTop)
{
_points[0] = new Point(x, y);
}
if (type == CornerType.RightTop)
{
_points[1] = new Point(x, y);
}
if (type == CornerType.RightBottom)
{
_points[2] = new Point(x, y);
}
if (type == CornerType.LeftBottom)
{
_points[3] = new Point(x, y);
}
this.Invalidate();
}
Vector2f GetCenter(CornerType cornerType)
{
Vector2f center = new Vector2f();
switch (cornerType)
{
case CornerType.TopLeft: center = Position + new Vector2f(Radius, Radius); break;
case CornerType.TopRight: center = new Vector2f(Position.X + Dimension.X - Radius, Position.Y + Radius); break;
case CornerType.BottomRight: center = Position + Dimension - new Vector2f(Radius, Radius); break;
case CornerType.BottomLeft: center = new Vector2f(Position.X + Radius, Position.Y + Dimension.Y - Radius); break;
}
return center;
}
private void AddRotatedCell(
Vector3 north,
Vector3 east,
Vector3 south,
Vector3 west,
Vector3 center,
Directions neighbors,
Directions edges,
Directions walls,
CornerType corner)
{
switch (neighbors)
{
case Directions.NorthWest:
AddOuterCornerCell(west, north, center, corner, edges, walls);
break;
case Directions.North:
AddStraightCell(west, north, east, center, corner, edges, walls);
break;
case Directions.North | Directions.West:
AddInnerCornerCell(north, east, south, west, center, corner, edges, walls);
break;
case Directions.NorthWest | Directions.SouthEast:
AddSaddleCell(north, east, south, west, center, corner, edges, walls);
break;
case Directions.All:
AddCenterCell(north, east, south, west, center, corner, edges, walls);
break;
default:
break;
}
}
/// <summary>
/// Resets value of <see cref="TopRight"/> to default value.
/// </summary>
protected virtual void ResetTopRight()
{
topRight = CornerType.Round;
}
/// <summary>
/// Resets value of <see cref="TopLeft"/> to default value.
/// </summary>
protected virtual void ResetTopLeft()
{
topLeft = CornerType.Round;
}
/// <summary>
/// Resets value of <see cref="BottomRight"/> to default value.
/// </summary>
protected virtual void ResetBottomRight()
{
bottomRight = CornerType.Round;
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
public void ReadXml(XmlReader reader)
{
var doc = new XmlDocument();
doc.Load(reader);
if (doc.GetElementsByTagName("BottomLeft").Count > 0)
BottomLeft =
(CornerType) Enum.Parse(typeof (CornerType), doc.GetElementsByTagName("BottomLeft")[0].InnerText);
if (doc.GetElementsByTagName("BottomRight").Count > 0)
BottomRight =
(CornerType) Enum.Parse(typeof (CornerType), doc.GetElementsByTagName("BottomRight")[0].InnerText);
if (doc.GetElementsByTagName("TopLeft").Count > 0)
TopLeft = (CornerType) Enum.Parse(typeof (CornerType), doc.GetElementsByTagName("TopLeft")[0].InnerText);
if (doc.GetElementsByTagName("TopRight").Count > 0)
TopRight =
(CornerType) Enum.Parse(typeof (CornerType), doc.GetElementsByTagName("TopRight")[0].InnerText);
}
private void AddCorner(ComplexPoly poly, Vector3 start, Vector3 end, Vector3 center, CornerType type, WallType wallType = WallType.None)
{
center = nudge(start, end, center);
switch (type)
{
case CornerType.Diamond:
break;
case CornerType.Square:
poly.AddLineSegment(start, center, end);
AddWallMesh(wallType, start, center, end);
return;
case CornerType.Rounded:
poly.AddLineSegment(
start,
(start + center) / 2,
(end + center) / 2,
end);
AddWallMesh(wallType,
start,
(start + center) / 2,
(end + center) / 2,
end);
return;
default:
break;
}
poly.AddLineSegment(start, end);
AddWallMesh(wallType, start, end);
}
private void TabCornerType_CheckedChanged(object sender, EventArgs e)
{
if ((((RadioButton)sender).Checked))
{
_cornerType = (CornerType)int.Parse((string)(((RadioButton)sender).Tag));
this.CreateImages();
}
}
private void LoadSettings()
{
TabStripSettings settings = new TabStripSettings();
settings = settings.Deserialize(_outputDirectory + _settingsFileName);
if (!string.IsNullOrEmpty(settings.SavedTabStripSettings.TabColor))
{
_tabColor = ColorTranslator.FromHtml(settings.SavedTabStripSettings.TabColor);
this.TabColorEntry.Text = settings.SavedTabStripSettings.TabColor;
}
if (!string.IsNullOrEmpty(settings.SavedTabStripSettings.BorderColor))
{
_borderColor = ColorTranslator.FromHtml(settings.SavedTabStripSettings.BorderColor);
this.BorderColorEntry.Text = settings.SavedTabStripSettings.BorderColor;
}
if (!string.IsNullOrEmpty(settings.SavedTabStripSettings.SelectedTabColor))
{
_selectedColor = ColorTranslator.FromHtml(settings.SavedTabStripSettings.SelectedTabColor);
this.SelectedColorEntry.Text = settings.SavedTabStripSettings.SelectedTabColor;
}
_borderWidth = settings.SavedTabStripSettings.BorderWidth;
this.BorderWidthEntry.Text = _borderWidth.ToString();
//_pottomPadding = settings.SavedTabStripSettings.BottomPadding;
_tabWidth = settings.SavedTabStripSettings.TabWidth;
this.TabWidthEntry.Text = _tabWidth.ToString();
_tabHeight = settings.SavedTabStripSettings.TabHeight;
this.TabHeightEntry.Text = _tabHeight.ToString();
_cornerHeight = settings.SavedTabStripSettings.CornerHeight * 2;
this.CornerHeightEntry.Text = settings.SavedTabStripSettings.CornerHeight.ToString();
_cornerWidth = settings.SavedTabStripSettings.CornerWidth * 2;
this.CornerWidthEntry.Text = settings.SavedTabStripSettings.CornerWidth.ToString();
if (!string.IsNullOrEmpty(settings.SavedTabStripSettings.TabType))
{
_tabType = (TabType)Enum.Parse(typeof(TabType), settings.SavedTabStripSettings.TabType);
switch (_tabType)
{
case TabType.LeftLean:
this.LeanLeftOption.Checked = true;
break;
case TabType.RightLean:
this.LeanRightOption.Checked = true;
break;
default:
this.SymetricalOption.Checked = true;
break;
}
}
if (!string.IsNullOrEmpty(settings.SavedTabStripSettings.TabCornerType))
{
_cornerType = (CornerType)Enum.Parse(typeof(CornerType), settings.SavedTabStripSettings.TabCornerType);
switch (_cornerType)
{
case CornerType.Chamfered:
this.ChamferedOption.Checked = true;
break;
default:
this.RoundedOption.Checked = true;
break;
}
}
if (this.OutputPathEntry.Text.Trim() != settings.SavedTabStripSettings.OutputDirectory.Trim())
{
DialogResult result = MessageBox.Show(_overrideOutputDirMessage,
this.Text, MessageBoxButtons.YesNo,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (result == DialogResult.Yes)
{
_outputDirectory = settings.SavedTabStripSettings.OutputDirectory;
this.OutputPathEntry.Text = _outputDirectory;
}
}
}
void AddStraightCell(Vector3 west, Vector3 north, Vector3 east, Vector3 center, CornerType corner, Directions edges, Directions walls)
{
var eastPoint = nudge(center, center, east);
var westPoint = nudge(center, center, west);
var northPoint = nudge(center, center, north);
switch (edges & Directions.North)
{
case Directions.North:
break;
case Directions.NorthEast:
switch (walls)
{
case Directions.NorthWest:
if (corner == CornerType.Square)
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
else
{
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, northPoint, westPoint, center, corner, WallType.None);
AddCorner(floorPolygons, westPoint, northPoint, center, CornerType.Square, WallType.Floor);
}
break;
case Directions.North:
AddCorner(wallPolygons, west, north, center, CornerType.Square, WallType.Both);
break;
default:
AddCorner(floorPolygons, west, north, center, CornerType.Square, WallType.Floor);
break;
}
break;
case Directions.NorthWest:
switch (walls)
{
case Directions.NorthEast:
if(corner == CornerType.Square)
AddCorner(wallPolygons, north, east, center, corner, WallType.Both);
else
{
AddCorner(wallPolygons, north, east, center, corner, WallType.Both);
AddCorner(floorPolygons, eastPoint, northPoint, center, corner, WallType.Both);
AddCorner(floorPolygons, northPoint, eastPoint, center, CornerType.Square, WallType.Floor);
}
break;
case Directions.North:
AddCorner(wallPolygons, north, east, center, CornerType.Square, WallType.Both);
break;
default:
AddCorner(floorPolygons, north, east, center, CornerType.Square, WallType.Floor);
break;
}
break;
default:
switch (walls)
{
case Directions.North:
AddStraight(wallPolygons, west, east, WallType.Both);
break;
case Directions.NorthWest:
//Todo: convert these to simple segments if the corners are square
AddStraight(floorPolygons, westPoint, east, WallType.Floor);
AddCorner(floorPolygons, north, westPoint, center, corner, WallType.None);
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
break;
case Directions.NorthEast:
AddStraight(floorPolygons, west, eastPoint, WallType.Floor);
AddCorner(floorPolygons, eastPoint, north, center, corner, WallType.None);
AddCorner(wallPolygons, north, east, center, corner, WallType.Wall);
break;
default:
AddStraight(floorPolygons, west, east, WallType.Floor);
break;
}
break;
}
}
void AddOuterCornerCell(Vector3 west, Vector3 north, Vector3 center, CornerType corner, Directions edges, Directions walls)
{
if ((edges & Directions.NorthWest) != Directions.NorthWest)
{
if ((walls & Directions.NorthWest) == Directions.NorthWest)
AddCorner(wallPolygons, west, north, center, corner, WallType.Both);
else
AddCorner(floorPolygons, west, north, center, corner, WallType.Floor);
}
}
void AddInnerCornerCell(Vector3 north, Vector3 east, Vector3 south, Vector3 west, Vector3 center, CornerType corner, Directions edges, Directions walls)
{
var eastPoint = nudge(center, center, east);
var westPoint = nudge(center, center, west);
var northPoint = nudge(center, center, north);
var southPoint = nudge(center, center, south);
switch (edges)
{
case Directions.East:
AddStraightCell(south, west, north, center, (walls == Directions.North)? CornerType.Square : corner, RotateCW(edges), RotateCW(walls) & Directions.North);
break;
case Directions.South:
AddStraightCell(west, north, east, center, (walls == Directions.West) ? CornerType.Square : corner, edges, walls & Directions.North);
break;
case Directions.North:
switch (walls)
{
case Directions.SouthWest:
case Directions.SouthWest | Directions.NorthEast:
if (corner == CornerType.Square)
{
AddCorner(wallPolygons, south, west, center, corner, WallType.Both);
}
else
{
AddCorner(floorPolygons, south, eastPoint, center, corner, WallType.Floor);
AddStraight(floorPolygons, eastPoint, westPoint, WallType.Floor);
AddCorner(floorPolygons, westPoint, south, center, corner, WallType.None);
AddCorner(wallPolygons, south, west, center, corner, WallType.Wall);
}
break;
case Directions.West:
if(corner == CornerType.Square)
{
AddCorner(wallPolygons, south, west, center, corner, WallType.Both);
}
else
{
AddCorner(wallPolygons, south, west, center, CornerType.Square, WallType.Both);
AddCorner(floorPolygons, eastPoint, southPoint, center, CornerType.Square, WallType.Floor);
AddCorner(floorPolygons, southPoint, eastPoint, center, corner, WallType.Floor);
}
break;
case Directions.West | Directions.North:
AddCorner(wallPolygons, south, eastPoint, center, corner, WallType.Both);
AddStraight(wallPolygons, eastPoint, west, WallType.Both);
break;
case Directions.NorthWest:
case Directions.NorthEast:
case Directions.North:
default:
AddCorner(floorPolygons, south, eastPoint, center, corner, WallType.Floor);
AddStraight(floorPolygons, eastPoint, west, WallType.Floor);
break;
}
break;
case Directions.West:
switch (walls)
{
case Directions.NorthEast:
case Directions.NorthEast | Directions.SouthWest:
if (corner == CornerType.Square)
{
AddCorner(wallPolygons, north, east, center, corner, WallType.Both);
}
else
{
AddStraight(floorPolygons, northPoint, southPoint, WallType.Floor);
AddCorner(floorPolygons, southPoint, eastPoint, center, corner, WallType.Floor);
AddCorner(floorPolygons, eastPoint, northPoint, center, corner, WallType.None);
AddCorner(wallPolygons, north, east, center, corner, WallType.Wall);
}
break;
case Directions.North:
if (corner == CornerType.Square)
{
AddCorner(wallPolygons, north, east, center, corner, WallType.Both);
}
else
{
AddCorner(floorPolygons, southPoint, eastPoint, center, corner, WallType.Floor);
AddCorner(floorPolygons, eastPoint, southPoint, center, CornerType.Square, WallType.None);
AddCorner(wallPolygons, north, east, center, CornerType.Square, WallType.Both);
}
break;
case Directions.North | Directions.West:
AddStraight(wallPolygons, north, southPoint, WallType.Both);
AddCorner(wallPolygons, southPoint, east, center, corner, WallType.Both);
break;
case Directions.NorthWest:
case Directions.SouthWest:
case Directions.West:
default:
AddStraight(floorPolygons, north, southPoint, WallType.Floor);
AddCorner(floorPolygons, southPoint, east, center, corner, WallType.Floor);
break;
}
break;
case Directions.North | Directions.West:
switch (walls)
{
case Directions.North | Directions.West:
if (corner != CornerType.Square)
{
AddCorner(wallPolygons, southPoint, eastPoint, center, corner, WallType.Both);
AddCorner(wallPolygons, eastPoint, southPoint, center, CornerType.Square, WallType.Both);
}
break;
case Directions.NorthWest:
case Directions.NorthEast:
case Directions.SouthWest:
case Directions.North:
case Directions.West:
case Directions.NorthEast | Directions.SouthWest:
default:
if (corner != CornerType.Square)
{
AddCorner(floorPolygons, southPoint, eastPoint, center, corner, WallType.Floor);
AddCorner(floorPolygons, eastPoint, southPoint, center, CornerType.Square, WallType.Floor);
}
break;
}
break;
case Directions.North | Directions.East:
switch (walls)
{
case Directions.West:
case Directions.North | Directions.West:
AddCorner(wallPolygons, south, west, center, CornerType.Square, WallType.Both);
break;
case Directions.SouthWest:
case Directions.NorthEast | Directions.SouthWest:
if (corner == CornerType.Square)
AddCorner(wallPolygons, south, west, center, CornerType.Square, WallType.Both);
else
{
AddCorner(wallPolygons, south, west, center, corner, WallType.Wall);
AddCorner(floorPolygons, westPoint, southPoint, center, corner, WallType.None);
AddCorner(floorPolygons, southPoint, westPoint, center, CornerType.Square, WallType.Floor);
}
break;
case Directions.NorthWest:
case Directions.NorthEast:
case Directions.North:
default:
AddCorner(floorPolygons, south, west, center, CornerType.Square, WallType.Floor);
break;
}
break;
case Directions.East | Directions.South:
switch (walls)
{
case Directions.North | Directions.West:
case Directions.North:
case Directions.West:
AddCorner(wallPolygons, west, north, center, CornerType.Square, WallType.Both);
break;
case Directions.NorthWest:
if(corner == CornerType.Square)
AddCorner(wallPolygons, west, north, center, CornerType.Square, WallType.Both);
else
{
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, northPoint, westPoint, center, corner, WallType.None);
AddCorner(floorPolygons, westPoint, northPoint, center, CornerType.Square, WallType.Floor);
}
break;
case Directions.NorthEast:
case Directions.SouthWest:
case Directions.NorthEast | Directions.SouthWest:
default:
AddCorner(floorPolygons, west, north, center, CornerType.Square, WallType.Floor);
break;
}
break;
case Directions.West | Directions.South:
switch (walls)
{
case Directions.North | Directions.West:
case Directions.North:
AddCorner(wallPolygons, north, east, center, CornerType.Square, WallType.Both);
break;
case Directions.NorthEast:
case Directions.NorthEast | Directions.SouthWest:
if (corner == CornerType.Square)
AddCorner(wallPolygons, north, east, center, corner, WallType.Both);
else
{
AddCorner(wallPolygons, north, east, center, corner, WallType.Both);
AddCorner(floorPolygons, eastPoint, northPoint, center, corner, WallType.None);
AddCorner(floorPolygons, northPoint, eastPoint, center, CornerType.Square, WallType.Floor);
}
break;
case Directions.NorthWest:
case Directions.SouthWest:
case Directions.West:
default:
AddCorner(floorPolygons, north, east, center, CornerType.Square, WallType.Floor);
break;
}
break;
default:
{
switch (walls)
{
case Directions.NorthWest:
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, north, west, center, corner, WallType.None);
AddCorner(floorPolygons, south, east, center, corner, WallType.Floor);
break;
case Directions.NorthEast:
AddCorner(wallPolygons, north, east, center, corner, WallType.Wall);
AddCorner(floorPolygons, eastPoint, north, center, corner, WallType.None);
AddCorner(floorPolygons, south, eastPoint, center, corner, WallType.Floor);
break;
case Directions.SouthWest:
AddCorner(wallPolygons, south, west, center, corner, WallType.Wall);
AddCorner(floorPolygons, west, southPoint, center, corner, WallType.None);
AddCorner(floorPolygons, southPoint, east, center, corner, WallType.Floor);
break;
case Directions.North:
AddStraight(wallPolygons, west, east, WallType.Wall);
AddStraight(floorPolygons, eastPoint, west, WallType.None);
AddCorner(floorPolygons, south, eastPoint, center, corner, WallType.Floor);
break;
case Directions.West:
AddStraight(wallPolygons, south, north, WallType.Wall);
AddStraight(floorPolygons, north, southPoint, WallType.None);
AddCorner(floorPolygons, southPoint, east, center, corner, WallType.Floor);
break;
case Directions.NorthEast | Directions.SouthWest:
AddCorner(wallPolygons, north, east, center, corner, WallType.Wall);
AddCorner(wallPolygons, south, west, center, corner, WallType.Wall);
AddCorner(floorPolygons, west, southPoint, center, corner, WallType.None);
AddCorner(floorPolygons, southPoint, eastPoint, center, corner, WallType.Floor);
AddCorner(floorPolygons, eastPoint, north, center, corner, WallType.None);
break;
case Directions.North | Directions.West:
AddCorner(wallPolygons, south, east, center, corner, WallType.Both);
break;
default:
AddCorner(floorPolygons, south, east, center, corner, WallType.Floor);
break;
}
}
break;
}
}
private void DefineRay(ST sideType, CornerType corner)
{
int k = 0;
//Debug.Log("Corner is " + corner);
switch (corner)
{
case CornerType.Closed:
ray[0] = 0;
ray[1] = 0;
return;
case CornerType.None:
k = 0;
break;
case CornerType.Open:
k = 1;
break;
}
//switch (sideType)
//{
// case ST.Top:
// ray[0] = 1 * k;
// ray[1] = 1;
// break;
// case ST.Right:
// ray[0] = 1;
// ray[1] = -1 * k;
// break;
// case ST.Down:
// ray[0] = -1 * k;
// ray[1] = -1;
// break;
// case ST.Left:
// ray[0] = -1;
// ray[1] = 1 * k;
// break;
//}
switch (sideType)
{
case ST.Top:
ray[0] = 1 * k;
ray[1] = -1;
break;
case ST.Right:
ray[0] = -1;
ray[1] = -1 * k;
break;
case ST.Down:
ray[0] = -1 * k;
ray[1] = 1;
break;
case ST.Left:
ray[0] = 1;
ray[1] = 1 * k;
break;
}
ray[0] *= inCast ? 1 : -1;
ray[1] *= inCast ? 1 : -1;
}
void AddRotatedCenterCell(Vector3 north, Vector3 east, Vector3 south, Vector3 west, Vector3 center, CornerType corner, Directions edges, Directions walls)
{
var eastPoint = nudge(center, center, east);
var westPoint = nudge(center, center, west);
var northPoint = nudge(center, center, north);
var southPoint = nudge(center, center, south);
switch (edges)
{
case Directions.North:
switch (walls)
{
case Directions.West | Directions.North:
if (corner == CornerType.Square)
{
AddCorner(wallPolygons, south, west, center, corner, WallType.Both);
AddCorner(floorPolygons, east, south, center, corner, WallType.Floor);
}
else
{
AddCorner(wallPolygons, south, eastPoint, center, corner, WallType.Wall);
AddStraight(wallPolygons, eastPoint, west, WallType.Both);
AddCorner(floorPolygons, east, south, center, corner, WallType.None);
}
break;
case Directions.NorthWest | Directions.SouthEast:
if (!_filledGaps)
corner = CornerType.Diamond;
AddCorner(wallPolygons, east, south, center, corner, WallType.Wall);
AddCorner(floorPolygons, south, eastPoint, center, corner, WallType.None);
AddStraight(floorPolygons, eastPoint, west, WallType.Floor);
break;
case Directions.All:
AddStraight(wallPolygons, east, west, WallType.Both);
break;
case Directions.North:
case Directions.NorthWest:
default:
AddStraight(floorPolygons, east, west, WallType.Floor);
break;
}
break;
case Directions.South:
switch (walls)
{
case Directions.NorthWest:
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, north, westPoint, center, corner, WallType.None);
AddStraight(floorPolygons, westPoint, east, WallType.Floor);
break;
case Directions.NorthWest | Directions.SouthEast:
if (!_filledGaps)
corner = CornerType.Diamond;
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, north, westPoint, center, corner, WallType.None);
AddStraight(floorPolygons, westPoint, east, WallType.Floor);
break;
case Directions.West | Directions.North:
case Directions.North:
case Directions.All:
AddStraight(wallPolygons, west, east, WallType.Both);
break;
default:
AddStraight(floorPolygons, west, east, WallType.Floor);
break;
}
break;
case Directions.East:
switch (walls)
{
case Directions.NorthWest:
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddStraight(floorPolygons, south, northPoint, WallType.Floor);
AddCorner(floorPolygons, northPoint, west, center, corner, WallType.None);
break;
case Directions.North:
AddCorner(wallPolygons, west, north, center, CornerType.Square, WallType.Both);
AddCorner(floorPolygons, south, west, center, CornerType.Square, WallType.Floor);
break;
case Directions.NorthWest | Directions.SouthEast:
if (!_filledGaps)
corner = CornerType.Diamond;
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddStraight(floorPolygons, south, northPoint, WallType.Floor);
AddCorner(floorPolygons, northPoint, west, center, corner, WallType.None);
break;
case Directions.West | Directions.North:
case Directions.All:
AddStraight(wallPolygons, south, north, WallType.Both);
break;
default:
AddStraight(floorPolygons, south, north, WallType.Floor);
break;
}
break;
case Directions.West:
switch (walls)
{
case Directions.North:
AddCorner(wallPolygons, north, east, center, CornerType.Square, WallType.Both);
AddCorner(floorPolygons, east, south, center, CornerType.Square, WallType.Floor);
break;
case Directions.West | Directions.North:
AddStraight(wallPolygons, north, southPoint, WallType.Both);
AddCorner(wallPolygons, southPoint, east, center, corner, WallType.Wall);
AddCorner(floorPolygons, east, south, center, corner, WallType.None);
break;
case Directions.NorthWest | Directions.SouthEast:
if (!_filledGaps)
corner = CornerType.Diamond;
AddCorner(wallPolygons, east, south, center, corner, WallType.Wall);
AddCorner(floorPolygons, south, east, center, corner, WallType.None);
AddStraight(floorPolygons, north, south, WallType.Floor);
break;
case Directions.All:
AddStraight(wallPolygons, north, south, WallType.Both);
break;
case Directions.NorthWest:
default:
AddStraight(floorPolygons, north, south, WallType.Floor);
break;
}
break;
case Directions.West | Directions.North:
switch (walls)
{
case Directions.West | Directions.North:
AddCorner(wallPolygons, eastPoint, southPoint, center, CornerType.Square, WallType.Both);
AddCorner(wallPolygons, southPoint, eastPoint, center, corner, WallType.None);
AddCorner(floorPolygons, east, south, center, corner, WallType.Floor);
break;
case Directions.NorthWest | Directions.SouthEast:
if (corner == CornerType.Square)
{
AddCorner(wallPolygons, east, south, center, corner, WallType.Wall);
}
else
{
AddCorner(floorPolygons, eastPoint, southPoint, center, CornerType.Square, WallType.Floor);
AddCorner(floorPolygons, southPoint, eastPoint, center, corner, WallType.None);
AddCorner(wallPolygons, east, south, center, corner, WallType.Wall);
}
break;
case Directions.All:
AddCorner(wallPolygons, east, south, center, CornerType.Square, WallType.Both);
break;
case Directions.North:
case Directions.NorthWest:
default:
AddCorner(floorPolygons, east, south, center, CornerType.Square, WallType.Floor);
break;
}
break;
case Directions.North | Directions.East:
switch (walls)
{
case Directions.West | Directions.North:
case Directions.All:
AddCorner(wallPolygons, south, west, center, CornerType.Square, WallType.Both);
break;
case Directions.North:
case Directions.NorthWest:
case Directions.NorthWest | Directions.SouthEast:
default:
AddCorner(floorPolygons, south, west, center, CornerType.Square, WallType.Floor);
break;
}
break;
case Directions.East | Directions.South:
switch (walls)
{
case Directions.NorthWest | Directions.SouthEast:
case Directions.NorthWest:
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, northPoint, westPoint, center, corner, WallType.None);
AddCorner(floorPolygons, westPoint, northPoint, center, CornerType.Square, WallType.Floor);
break;
case Directions.North:
case Directions.West | Directions.North:
case Directions.All:
AddCorner(wallPolygons, west, north, center, CornerType.Square, WallType.Both);
break;
default:
AddCorner(floorPolygons, west, north, center, CornerType.Square, WallType.Floor);
break;
}
break;
case Directions.South | Directions.West:
switch (walls)
{
case Directions.North:
case Directions.West | Directions.North:
case Directions.All:
AddCorner(wallPolygons, north, east, center, CornerType.Square, WallType.Both);
break;
case Directions.NorthWest | Directions.SouthEast:
case Directions.NorthWest:
default:
AddCorner(floorPolygons, north, east, center, CornerType.Square, WallType.Floor);
break;
}
break;
default:
switch (walls)
{
case Directions.NorthWest:
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, north, west, center, corner, WallType.None);
break;
case Directions.North:
AddStraight(wallPolygons, west, east, WallType.Wall);
AddStraight(floorPolygons, east, west, WallType.None);
break;
case Directions.West | Directions.North:
AddCorner(wallPolygons, south, east, center, corner, WallType.Wall);
AddCorner(floorPolygons, east, south, center, corner, WallType.None);
break;
case Directions.NorthWest | Directions.SouthEast:
if (!_filledGaps)
corner = CornerType.Diamond;
AddCorner(wallPolygons, west, north, center, corner, WallType.Wall);
AddCorner(floorPolygons, north, west, center, corner, WallType.None);
AddCorner(wallPolygons, east, south, center, corner, WallType.Wall);
AddCorner(floorPolygons, south, east, center, corner, WallType.None);
break;
default:
break;
}
break;
}
}
/// <summary>
/// Assigns Values of supplied <see cref="CornerShape"/> to current object.
/// </summary>
/// <param name="shape"><see cref="CornerShape"/> object whose value is to be assigned.</param>
public void Assign(CornerShape shape)
{
TopLeft = shape.topLeft;
TopRight = shape.topRight;
BottomLeft = shape.bottomLeft;
BottomRight = shape.bottomRight;
}
public static GraphicsPath CreatePath(
RectangleF rect,
int cornerRadius,
int margin,
CornerType corners
)
{
GraphicsPath graphicsPath = new GraphicsPath() ;
float xOffset = rect.X + margin ;
float yOffset = rect.Y + margin ;
float xExtent = rect.X + rect.Width - margin ;
float yExtent = rect.Y + rect.Height - margin ;
int diameter = cornerRadius << 1 ;
// top arc
if ((corners & CornerType.TopLeft) != 0) {
graphicsPath.AddArc(new RectangleF(xOffset, yOffset, diameter, diameter), 180, 90) ;
} else {
graphicsPath.AddLine(new PointF(xOffset, yOffset + cornerRadius), new PointF(xOffset, yOffset)) ;
graphicsPath.AddLine(new PointF(xOffset, yOffset), new PointF(xOffset + cornerRadius, yOffset)) ;
}
// top line
graphicsPath.AddLine(new PointF(xOffset + cornerRadius, yOffset), new PointF(xExtent - cornerRadius, yOffset)) ;
// top right arc
if ((corners & CornerType.TopRight) != 0)
graphicsPath.AddArc(new RectangleF(xExtent - diameter, yOffset, diameter,diameter), 270, 90) ;
else {
graphicsPath.AddLine(new PointF(xExtent - cornerRadius, yOffset), new PointF(xExtent, yOffset)) ;
graphicsPath.AddLine(new PointF(xExtent, yOffset), new PointF(xExtent, yOffset + cornerRadius)) ;
}
// right line
graphicsPath.AddLine(new PointF(xExtent, yOffset + cornerRadius), new PointF(xExtent, yExtent - cornerRadius)) ;
// bottom right arc
if ((corners & CornerType.BottomRight) != 0)
graphicsPath.AddArc(new RectangleF(xExtent - diameter, yExtent - diameter, diameter,diameter), 0, 90) ;
else {
graphicsPath.AddLine(new PointF(xExtent, yExtent - cornerRadius),new PointF(xExtent, yExtent)) ;
graphicsPath.AddLine(new PointF(xExtent, yExtent),new PointF(xExtent - cornerRadius, yExtent)) ;
}
// bottom line
graphicsPath.AddLine(new PointF(xExtent - cornerRadius, yExtent), new PointF(xOffset + cornerRadius, yExtent)) ;
// bottom left arc
if ((corners & CornerType.BottomLeft) != 0)
graphicsPath.AddArc(new RectangleF(xOffset, yExtent - diameter,diameter,diameter), 90, 90) ;
else {
graphicsPath.AddLine(new PointF(xOffset + cornerRadius, yExtent), new PointF(xOffset, yExtent)) ;
graphicsPath.AddLine(new PointF(xOffset, yExtent), new PointF(xOffset, yExtent - cornerRadius)) ;
}
// left line
graphicsPath.AddLine(new PointF(xOffset, yExtent - cornerRadius), new PointF(xOffset, yOffset + cornerRadius)) ;
graphicsPath.CloseFigure() ;
return graphicsPath ;
}
void AddCenterCell(Vector3 north, Vector3 east, Vector3 south, Vector3 west, Vector3 center, CornerType corner, Directions edges, Directions walls)
{
switch (walls)
{
case Directions.None:
case Directions.NorthWest:
case Directions.North:
case Directions.North | Directions.SouthWest:
case Directions.NorthWest | Directions.SouthEast:
case Directions.All:
AddRotatedCenterCell(north, east, south, west, center, corner, edges, walls);
break;
case Directions.NorthEast:
case Directions.East:
case Directions.North | Directions.SouthEast:
case Directions.NorthEast | Directions.SouthWest:
AddRotatedCenterCell(east, south, west, north, center, corner, RotateCCW(edges), RotateCCW(walls));
break;
case Directions.SouthEast:
case Directions.South:
case Directions.NorthEast | Directions.South:
AddRotatedCenterCell(south, west, north, east, center, corner, Rotate180(edges), Rotate180(walls));
break;
case Directions.SouthWest:
case Directions.West:
case Directions.West | Directions.SouthEast:
AddRotatedCenterCell(west, north, east, south, center, corner, RotateCW(edges), RotateCW(walls));
break;
}
}
private void AddCorner(CornerType cornerType)
{
Sprite corner = new Sprite(GetCorner().Sprite);
//corner.Scale = GetScaleFactor();
corner.Origin = new Vector2f(
corner.Width / 2F,
corner.Height / 2F);
switch (cornerType)
{
case CornerType.TopLeft: corner.Rotation = 90F; break;
case CornerType.TopRight: corner.Rotation = 180F; break;
case CornerType.BottomLeft: corner.Rotation = 0F; break;
case CornerType.BottomRight: corner.Rotation = 270F; break;
default: break;
}
Corners[cornerType] = corner;
}
private Vector2f GetCornerDimension(CornerType cornerType)
{
switch (cornerType)
{
case CornerType.TopLeft: return new Vector2f(GetCorner().Dimension.Y, GetCorner().Dimension.X);
case CornerType.TopRight: return GetCorner().Dimension;
case CornerType.BottomLeft: return GetCorner().Dimension;
case CornerType.BottomRight: return new Vector2f(GetCorner().Dimension.Y, GetCorner().Dimension.X);
default: return GetCorner().Dimension;
}
}
void ChangeCornerPosition(CornerType type, int x, int y)
{
if (type == CornerType.LeftTop)
{
_points[0] = new Point(x, y);
}
if (type == CornerType.RightTop)
{
_points[1] = new Point(x, y);
}
if (type == CornerType.RightBottom)
{
_points[2] = new Point(x, y);
}
if (type == CornerType.LeftBottom)
{
_points[3] = new Point(x, y);
}
this.Invalidate();
}
void AddSaddleCell(Vector3 north, Vector3 east, Vector3 south, Vector3 west, Vector3 center, CornerType corner, Directions edges, Directions walls)
{
if (!_filledGaps)
corner = CornerType.Diamond;
switch (edges)
{
case Directions.East | Directions.North:
case Directions.West | Directions.South:
break;
case Directions.North:
case Directions.West:
case Directions.North | Directions.West:
switch (walls)
{
case Directions.NorthWest | Directions.SouthEast:
case Directions.SouthEast:
AddCorner(wallPolygons, east, south, center, corner, WallType.Both);
break;
default:
AddCorner(floorPolygons, east, south, center, corner, WallType.Floor);
break;
}
break;
case Directions.East:
case Directions.South:
case Directions.East | Directions.South:
switch (walls)
{
case Directions.NorthWest | Directions.SouthEast:
case Directions.NorthWest:
AddCorner(wallPolygons, west, north, center, corner, WallType.Both);
break;
default:
AddCorner(floorPolygons, west, north, center, corner, WallType.Floor);
break;
}
break;
default:
switch (walls)
{
case Directions.NorthWest | Directions.SouthEast:
AddCorner(wallPolygons, east, south, center, corner, WallType.Both);
AddCorner(wallPolygons, west, north, center, corner, WallType.Both);
break;
case Directions.NorthWest:
AddCorner(floorPolygons, east, south, center, corner, WallType.Floor);
AddCorner(wallPolygons, west, north, center, corner, WallType.Both);
break;
case Directions.SouthEast:
AddCorner(wallPolygons, east, south, center, corner, WallType.Both);
AddCorner(floorPolygons, west, north, center, corner, WallType.Floor);
break;
default:
AddCorner(floorPolygons, east, south, center, corner, WallType.Floor);
AddCorner(floorPolygons, west, north, center, corner, WallType.Floor);
break;
}
break;
}
}
