public static void DrawImage(this RenderContext context, Image image, float destX, float destY, InterpolationMode interpolationMode, CompositeMode compositeMode)
{
var dstOffset = new RawVector2(destX, destY);
context.RenderTarget.DeviceContext2D.DrawImage(image, dstOffset, null, interpolationMode, compositeMode);
}
public static void FillClassicMusicalVerticalParallelRect(this RenderTarget renderTarget, RawVector2 startPos, RawVector2 endPos, Color color, float strokeWidth, float scale = 1f, bool shadow = false)
{
PointF[] pathPoints;
if (startPos.X > endPos.X)
{
RawVector2 vector = new RawVector2 {
X = startPos.X,
Y = startPos.Y
};
startPos.X = endPos.X;
startPos.Y = endPos.Y;
endPos.X = vector.X;
endPos.Y = vector.Y;
}
if (scale > 0f)
{
endPos.X = startPos.X + ((endPos.X - startPos.X) * scale);
endPos.Y = startPos.Y + ((endPos.Y - startPos.Y) * scale);
}
else
{
startPos.X += (endPos.X - startPos.X) * (1f + scale);
startPos.Y += (endPos.Y - startPos.Y) * (1f + scale);
}
startPos.X--;
using (GraphicsPath path = new GraphicsPath())
{
float num = strokeWidth / 2f;
path.AddLine(startPos.X, startPos.Y, startPos.X, startPos.Y - num);
path.AddLine(startPos.X, startPos.Y - num, endPos.X, endPos.Y - num);
path.AddLine(endPos.X, endPos.Y - num, endPos.X, endPos.Y + num);
path.AddLine(endPos.X, endPos.Y + num, startPos.X, startPos.Y + num);
path.AddLine(startPos.X, startPos.Y + num, startPos.X, startPos.Y);
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
GeometrySink sink;
int num2;
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (num2 = 1; num2 < pathPoints.Length; num2++)
{
sink.AddLine(new RawVector2(pathPoints[num2].X, pathPoints[num2].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
if (shadow)
{
PathGeometry geometry2 = new PathGeometry(factory);
if (shadow && (pathPoints.Length > 1))
{
sink = geometry2.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X + 2f, pathPoints[0].Y + 2f), FigureBegin.Filled);
for (num2 = 1; num2 < pathPoints.Length; num2++)
{
sink.AddLine(new RawVector2(pathPoints[num2].X + 2f, pathPoints[num2].Y + 2f));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, Color.FromArgb((int)(color.A * 0.2f), color).ToRawColor4(1f));
renderTarget.FillGeometry(geometry2, brush);
brush.Dispose();
geometry2.Dispose();
}
SolidColorBrush brush2 = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush2);
brush2.Dispose();
geometry.Dispose();
}
}
public override void stepFinish()
{
movement = new RawVector2(transform.M31 - oldLocation.X, transform.M32 - oldLocation.Y);
base.stepFinish();
}
public static void DrawBezierLine(this RenderTarget renderTarget, RawVector2 pStart, RawVector2 pEnd, float heightDiff, float mpRatio, Color color)
{
renderTarget.DrawBezierLine(pStart, pEnd, heightDiff, mpRatio, color, 1f, null, false);
}
public static void DrawTextLayout(this RenderTarget renderTarget, SharpDX.DirectWrite.Factory writeFactory, string text, RawVector2 pos, string fontFamilyName, float fontSize, Color color, TextAlignment textAlignment, ParagraphAlignment paragraphAlignment, SharpDX.DirectWrite.FontStyle fontStyle = 0, FontWeight fontWeight = 700)
{
Trimming trimming;
InlineObject obj2;
TextFormat textFormat = new TextFormat(writeFactory, fontFamilyName, fontWeight, fontStyle, FontStretch.Normal, fontSize);
textFormat.GetTrimming(out trimming, out obj2);
trimming.Granularity = TrimmingGranularity.Word;
textFormat.SetTrimming(trimming, obj2);
textFormat.TextAlignment = TextAlignment.Center;
textFormat.ParagraphAlignment = ParagraphAlignment.Center;
TextLayout layout = new TextLayout(writeFactory, text, textFormat, 1920f, 1080f);
textFormat.TextAlignment = textAlignment;
textFormat.ParagraphAlignment = paragraphAlignment;
TextLayout textLayout = new TextLayout(writeFactory, text, textFormat, layout.Metrics.Width + 2f, layout.Metrics.Height);
layout.Dispose();
textFormat.Dispose();
switch (textAlignment)
{
case TextAlignment.Trailing:
pos.X -= textLayout.Metrics.Width;
break;
case TextAlignment.Center:
case TextAlignment.Justified:
pos.X -= textLayout.Metrics.Width / 2f;
break;
}
switch (paragraphAlignment)
{
case ParagraphAlignment.Far:
pos.Y -= textLayout.Metrics.Height;
break;
case ParagraphAlignment.Center:
pos.Y -= textLayout.Metrics.Height / 2f;
break;
}
SolidColorBrush defaultForegroundBrush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.DrawTextLayout(pos, textLayout, defaultForegroundBrush, DrawTextOptions.Clip);
defaultForegroundBrush.Dispose();
textLayout.Dispose();
}
public static void DrawBezierLine(this RenderTarget renderTarget, RawVector2 pStart, RawVector2 pEnd, float heightDiff, float mpRatio, Color color, float strokeWidth, StrokeStyle strokeStyle, bool disposeStrokeStyle = true)
{
mpRatio = mpRatio.Clamp(0f, 1f);
float num = pEnd.X - pStart.X;
float num2 = pEnd.Y - pStart.Y;
RawVector2 vector = new RawVector2(pStart.X + (num * mpRatio), (pStart.Y + (num2 * mpRatio)) + heightDiff);
RawVector2 vector2 = new RawVector2(pStart.X + (num * (1f - mpRatio)), (pStart.Y + (num2 * (1f - mpRatio))) + heightDiff);
renderTarget.DrawBezierLine(pStart, vector, vector2, pEnd, color, strokeWidth, strokeStyle, disposeStrokeStyle);
}
public static void DrawBitmap(this RenderTarget renderTarget, SharpDX.WIC.Bitmap bitmap, RawVector2 pos, float opacity = 1f)
{
renderTarget.DrawBitmap(SharpDX.Direct2D1.Bitmap.FromWicBitmap(renderTarget, bitmap), pos, null, opacity, SharpDX.Direct2D1.BitmapInterpolationMode.NearestNeighbor);
}
public void Draw(SpriteResource sprite, RawVector2 origin, float rotate) => Draw(sprite, origin, rotate, new RawVector2(.5f, .5f));
public void Draw(SpriteResource sprite, RawVector2 origin) => Draw(sprite, origin, 0);
/// <unmanaged>HRESULT ID2D1CommandSink::DrawLine([In] D2D_POINT_2F point0,[In] D2D_POINT_2F point1,[In] ID2D1Brush* brush,[In] float strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle)</unmanaged>
public void DrawLine(RawVector2 point0, RawVector2 point1, Brush brush, float strokeWidth, StrokeStyle strokeStyle)
{
DrawLine_(point0, point1, brush, strokeWidth, strokeStyle);
}
public void Draw(SpriteResource sprite, RawVector2 origin, float rotate, RawVector2 rotateOrigin) => Draw(sprite, new RawRectangleF(origin.X, origin.Y, origin.X + (sprite.Rect.Right - sprite.Rect.Left), origin.Y + (sprite.Rect.Bottom - sprite.Rect.Top)), rotate, rotateOrigin);
/// <unmanaged>HRESULT ID2D1CommandSink::DrawGlyphRun([In] D2D_POINT_2F baselineOrigin,[In] const DWRITE_GLYPH_RUN* glyphRun,[In, Optional] const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription,[In] ID2D1Brush* foregroundBrush,[In] DWRITE_MEASURING_MODE measuringMode)</unmanaged>
public void DrawGlyphRun(RawVector2 baselineOrigin, DirectWrite.GlyphRun glyphRun, DirectWrite.GlyphRunDescription glyphRunDescription, Brush foregroundBrush, MeasuringMode measuringMode)
{
DrawGlyphRun_(baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
/// <summary>
/// Draw a black background behind where our crosshair will go
/// </summary>
/// <param name="Location"></param>
/// <param name="Radius"></param>
private void DrawCrosshairBackground(RawVector2 Location, float Radius)
{
Surface.RenderTarget2D.FillEllipse(new Ellipse(Location, Radius + 5f, Radius + 5f), BlackBrush);
}
/// <summary>
/// Render our training layer
/// </summary>
/// <param name="renderTime"></param>
public override void Render(RenderTime renderTime)
{
base.Render(renderTime);
if (MM_Repository.Training == null || MM_Repository.Training.TrainingMode == Data_Elements.Training.MM_Training.enumTrainingMode.NotTraning)
{
return;
}
else
{
MM_Repository.Training.CheckTimes();
String TextToDraw;
Brush DrawBrush;
//Determine our question text and color
if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.UserWon)
{
TextToDraw = "Congratulations! You won!";
DrawBrush = LightGreenBrush;
}
else if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.UserFailed)
{
TextToDraw = "Sorry - please play again!";
DrawBrush = RedBrush;
}
else
{
TextToDraw = MM_Repository.Training.QuestionText;
DrawBrush = QuestionBrush;
}
//Now, draw all of our strings
DrawString(TextToDraw, VerticalAlignment.Top, HorizontalAlignment.Center, DrawBrush, QuestionFormat);
DrawString("Score: " + MM_Repository.Training.Score.ToString("#,##0"), VerticalAlignment.Top, HorizontalAlignment.Left, DrawBrush, QuestionFormat);
DrawString("[" + (MM_Repository.Training.CurrentLevel.ID + 1).ToString() + "]: " + MM_Repository.Training.CurrentLevel.Title, VerticalAlignment.Bottom, HorizontalAlignment.Left, DrawBrush, QuestionFormat);
//If we're in question mode, show our countdown timer
if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.QuestionAsked)
{
double TimeLeft = MM_Repository.Training.CurrentLevel.QuestionTimeout - MM_Repository.Training.TimeSincePresentation;
DrawString("Time: " + TimeLeft.ToString("0"), VerticalAlignment.Top, HorizontalAlignment.Right, DrawBrush, QuestionFormat);
}
//If we have the incorrect answer, draw accordingly.
if (MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.AnswerCorrect || MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.AnswerWrong)
{
bool Correct = MM_Repository.Training.TrainingMode == MM_Training.enumTrainingMode.AnswerCorrect;
DrawBrush = Correct ? CorrectBrush : IncorrectBrush;
DrawString(MM_Repository.Training.AnswerText, VerticalAlignment.Top, HorizontalAlignment.Center, DrawBrush, QuestionFormat, 1, 2);
RawVector2 CorrectAnswerXY = MM_Coordinates.LngLatToScreenVector2(MM_Repository.Training.CorrectAnswer, Surface.Coordinates.ZoomLevel);
CorrectAnswerXY.X -= Surface.Coordinates.TopLeftXY.X;
CorrectAnswerXY.Y -= Surface.Coordinates.TopLeftXY.Y;
if (!MM_Repository.Training.UserAnswer.IsEmpty)
{
RawVector2 UserAnswerXY = MM_Coordinates.LngLatToScreenVector2(MM_Repository.Training.UserAnswer, Surface.Coordinates.ZoomLevel);
UserAnswerXY.X -= Surface.Coordinates.TopLeftXY.X;
UserAnswerXY.Y -= Surface.Coordinates.TopLeftXY.Y;
DrawCrosshairBackground(UserAnswerXY, 8f);
Surface.RenderTarget2D.DrawLine(CorrectAnswerXY, UserAnswerXY, BlackBrush, 5f);
DrawCrosshairBackground(CorrectAnswerXY, 15f);
Surface.RenderTarget2D.DrawLine(CorrectAnswerXY, UserAnswerXY, CorrectBrush, 3f);
DrawCrosshair(WhiteBrush, UserAnswerXY, 10, "");
}
if (MM_Repository.Training.TargetElement is MM_Substation)
{
DrawCrosshair(DrawBrush, CorrectAnswerXY, 20, ((MM_Substation)MM_Repository.Training.TargetElement).LongName);
}
else
{
DrawCrosshair(DrawBrush, CorrectAnswerXY, 20, MM_Repository.Training.TargetElement.Name);
}
}
}
}
private void TxtView_D2DPaint(D2DGraphics g)
{
if (!string.IsNullOrWhiteSpace(BackGroundText) && !isHideBackGroundText)
{
g.RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
SolidColorBrush brush = new SolidColorBrush(g.RenderTarget, GDIDataD2DUtils.TransToRawColor4(BackGroundTextColor));
TextFormat textFormat = new TextFormat(D2DGraphics.dwriteFactory, foreFont.FamilyName, foreFont.Weight, foreFont.Style, foreFont.Size)
{
TextAlignment = TextAlignment.Leading, ParagraphAlignment = ParagraphAlignment.Center
};
textFormat.WordWrapping = WordWrapping.Wrap;
SharpDX.RectangleF textRegionRect =
new SharpDX.RectangleF(0, 0, Width - 1, Height - 1);
g.RenderTarget.DrawText(BackGroundText, textFormat, textRegionRect, brush, DrawTextOptions.Clip);
}
if (metricsList != null)
{
g.RenderTarget.AntialiasMode = AntialiasMode.Aliased;
SharpDX.Direct2D1.Brush brush = new SolidColorBrush(g.RenderTarget, SharpDX.Color.SkyBlue);
foreach (HitTestMetrics m in metricsList)
{
SharpDX.RectangleF textRegionRect =
new SharpDX.RectangleF((float)Math.Ceiling(m.Left), (float)Math.Ceiling(m.Top), (float)Math.Ceiling(m.Width), (float)Math.Ceiling(m.Height));
g.RenderTarget.FillRectangle(textRegionRect, brush);
}
}
g.RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
if (CurrentTextLayout != null && scTextRenderer != null)
{
CurrentTextLayout.Draw(scTextRenderer, 0, 0);
}
if (cursorState == 1)
{
g.RenderTarget.AntialiasMode = AntialiasMode.Aliased;
RawRectangleF rect =
new RawRectangleF(
hitTestMetrics[cursorIdx].Left,
hitTestMetrics[cursorIdx].Top,
hitTestMetrics[cursorIdx].Left + hitTestMetrics[cursorIdx].Width,
hitTestMetrics[cursorIdx].Top + hitTestMetrics[cursorIdx].Height);
RawVector2 pt0;
RawVector2 pt1;
if (isTrailingHit[cursorIdx] == false)
{
pt0 = new RawVector2((float)Math.Ceiling(rect.Left), (float)Math.Ceiling(rect.Top));
pt1 = new RawVector2((float)Math.Ceiling(rect.Left), (float)Math.Ceiling(rect.Bottom));
}
else
{
pt0 = new RawVector2((float)Math.Ceiling(rect.Right), (float)Math.Ceiling(rect.Top));
pt1 = new RawVector2((float)Math.Ceiling(rect.Right), (float)Math.Ceiling(rect.Bottom));
}
RawColor4 color = GDIDataD2DUtils.TransToRawColor4(Color.FromArgb(255, 255, 0, 0));
SharpDX.Direct2D1.Brush brushx = new SolidColorBrush(g.RenderTarget, color);
if (pt0.X == 0 && pt1.X == 0)
{
pt1.X = pt0.X = 1;
}
g.RenderTarget.DrawLine(pt0, pt1, brushx);
}
}
private void RenderingDrawTriangleWithText(float[] center, string text, float radius, double percentage, int[] color, int thickness, bool drawWorldMap, bool fill = false)
{
if (drawWorldMap)
{
radius = radius * 20;
}
double segments = 3;
RawVector2[] pts = new RawVector2[(int)segments + 1];
double angle = 0;
double segmentSize = (360 * percentage) / segments;
int[] sCenter;
if (!Helpers.ViewTransform.ToScreen.WorldToScreen(center, out sCenter, drawWorldMap))
{
return;
}
int count = 0;
if (percentage < 1)
{
pts = new RawVector2[(int)segments + 3];
pts[0] = new RawVector2(sCenter[0], sCenter[1]);
count = 1;
}
int[] screen = null;
while (angle <= (360 * percentage))
{
float X = (float)(center[0] + (radius * Math.Cos(angle / (180 / Math.PI))));
float Z = (float)(center[2] + (radius * Math.Sin(angle / (180 / Math.PI))));
if (Helpers.ViewTransform.ToScreen.WorldToScreen(new float[] { X, center[1], Z }, out screen, drawWorldMap))
{
pts[count] = new RawVector2(screen[0], screen[1]);
}
else
{
return;
}
angle += segmentSize;
count++;
}
if (percentage < 1)
{
pts[pts.Length - 1] = pts[0];
}
//if (pts.Any(x => x.X == 0 || x.Y == 0))
//return;
pathGeometry = new PathGeometry(factory);
geometrySink = pathGeometry.Open();
geometrySink.BeginFigure(pts[0], new FigureBegin());
geometrySink.AddLines(pts);
geometrySink.EndFigure(new FigureEnd());
geometrySink.Close();
ChangeColor(color);
device.DrawGeometry(pathGeometry, solidColorBrush);
if (fill)
{
device.FillGeometry(pathGeometry, solidColorBrush);
}
pathGeometry.Dispose();
geometrySink.Dispose();
RenderingDrawText(screen, color, text, drawWorldMap);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Сериализация двухмерного вектора в строку
/// </summary>
/// <param name="vector">Двухмерный вектор</param>
/// <returns>Строка данных</returns>
//---------------------------------------------------------------------------------------------------------
public static String Serialize(this RawVector2 vector)
{
return(String.Format("{0};{1}", vector.X, vector.Y));
}
private void RenderingDrawSquare(float[] center, float squaresize, int[] color, int thickness, bool drawWorldMap, bool fill = false)
{
if (drawWorldMap)
{
squaresize = squaresize * 1f;
}
RawVector2[] pts = new RawVector2[4];
bool draw = false;
int[] screen;
float[] buffer = center.ToArray();
buffer[0] -= squaresize / 2;
buffer[2] -= squaresize / 2;
if (Helpers.ViewTransform.ToScreen.WorldToScreen(buffer, out screen, drawWorldMap))
{
pts[0] = new RawVector2(screen[0], screen[1]);
buffer = center.ToArray();
buffer[0] += squaresize / 2;
buffer[2] -= squaresize / 2;
if (Helpers.ViewTransform.ToScreen.WorldToScreen(buffer, out screen, drawWorldMap))
{
pts[1] = new RawVector2(screen[0], screen[1]);
buffer = center.ToArray();
buffer[0] += squaresize / 2;
buffer[2] += squaresize / 2;
if (Helpers.ViewTransform.ToScreen.WorldToScreen(buffer, out screen, drawWorldMap))
{
pts[2] = new RawVector2(screen[0], screen[1]);
buffer = center.ToArray();
buffer[0] -= squaresize / 2;
buffer[2] += squaresize / 2;
if (Helpers.ViewTransform.ToScreen.WorldToScreen(buffer, out screen, drawWorldMap))
{
pts[3] = new RawVector2(screen[0], screen[1]);
draw = true;
}
}
}
}
if (!draw)
{
return;
}
pathGeometry = new PathGeometry(factory);
geometrySink = pathGeometry.Open();
geometrySink.BeginFigure(pts[0], new FigureBegin());
geometrySink.AddLines(new RawVector2[] { pts[1], pts[2], pts[3], pts[0] });
geometrySink.EndFigure(new FigureEnd());
geometrySink.Close();
ChangeColor(color);
device.DrawGeometry(pathGeometry, solidColorBrush);
if (fill)
{
device.FillGeometry(pathGeometry, solidColorBrush);
}
pathGeometry.Dispose();
geometrySink.Dispose();
}
public static void DrawBitmap(this RenderTarget renderTarget, SharpDX.Direct2D1.Bitmap bitmap, RawVector2 pos)
{
renderTarget.DrawBitmap(bitmap, pos, null, 1f, SharpDX.Direct2D1.BitmapInterpolationMode.NearestNeighbor);
}
/// <summary>
/// Initialize a new flow path
/// </summary>
/// <param name="Point1">The first part of the line</param>
/// <param name="Point2">The second part of the line</param>
public MM_NetworkMap_FlowPath(RawVector2 Point1, RawVector2 Point2)
{
this.CurDimension = 0;
RecomputeFlow(Point1, Point2);
}
public static void DrawBitmap(this RenderTarget renderTarget, SharpDX.Direct2D1.Bitmap bitmap, RawVector2 pos, Size2F?size, float opacity = 1f, SharpDX.Direct2D1.BitmapInterpolationMode interpolationMode = 0)
{
if (!size.HasValue)
{
size = new Size2F?(bitmap.Size);
}
renderTarget.DrawBitmap(bitmap, new RawRectangleF(pos.X, pos.Y, pos.X + size.Value.Width, pos.Y + size.Value.Height), opacity, interpolationMode);
}
/// <summary>
/// Create a <see cref="LinearGradientBrush"/> from parameters.
/// </summary>
/// <param name="renderTarget">The render target to use.</param>
/// <param name="gradientStops">Collection of <see cref="GradientStop"/>s.</param>
/// <param name="startPosition">The <see cref="LinearGradientBrush"/> start vector.</param>
/// <param name="endPosition">The <see cref="LinearGradientBrush"/> end vector.</param>
/// <returns><see cref="LinearGradientBrush"/></returns>
public static LinearGradientBrush GetLinearGradientBrush(RenderTarget renderTarget, IList <GradientStop> gradientStops, RawVector2 startPosition, RawVector2 endPosition)
{
var lprops = new LinearGradientBrushProperties
{
StartPoint = startPosition,
EndPoint = endPosition
};
var brush = new LinearGradientBrush(renderTarget, lprops, null, new GradientStopCollection(renderTarget, gradientStops.ToArray()));
return(brush);
}
public static void DrawTextLayout(this RenderTarget renderTarget, SharpDX.DirectWrite.Factory writeFactory, string text, RawVector2 pos, string fontFamilyName, float fontSize, Color color, TextAlignment textAlignment, SharpDX.DirectWrite.FontStyle fontStyle = 0)
{
renderTarget.DrawTextLayout(writeFactory, text, pos, fontFamilyName, fontSize, color, textAlignment, ParagraphAlignment.Near, fontStyle, FontWeight.Bold);
}
/// <summary>Create an indexed palette and linear brush for linear gradients.</summary>
/// <param name="surface">The <see cref="Direct3DSurface"/> used for rendering.</param>
/// <param name="gradientStops">Collection of gradient stops to use in brush and palette.</param>
/// <param name="paletteSize">Number of indexed colors to create.</param>
/// <param name="startPosition"><see cref="LinearGradientBrush"/> start vector.</param>
/// <param name="endPosition"><see cref="LinearGradientBrush"/> end vector.</param>
public LinearGradientPalette(Direct3DSurface surface, IEnumerable <GradientStop> gradientStops, RawVector2 startPosition, RawVector2 endPosition, int paletteSize = 256)
{
IsDisposed = false;
_surface = surface;
_paletteSize = paletteSize;
_startPosition = startPosition;
_endPosition = endPosition;
_gradientStops = gradientStops.ToList();
Update();
}
private static void DrawTie(this RenderTarget renderTarget, SharpDX.DirectWrite.Factory writeFactory, RawVector2 startPos, RawVector2 endPos, Color color, bool flipVertical = false, bool isTriplet = false)
{
PointF[] pathPoints;
RawVector2 vector;
RawVector2 vector2;
using (GraphicsPath path = new GraphicsPath())
{
float num = 45f;
float num2 = 0.3f;
float num3 = startPos.GetDistanceByRawVector2(endPos).Clamp(64f, 256f);
float num4 = startPos.GetAngleByRawVector2(endPos);
float num5 = endPos.GetAngleByRawVector2(startPos);
if (flipVertical)
{
vector = startPos.GetRawVector2ByPolarCoordinates(num4 + num, num3 * num2);
vector2 = endPos.GetRawVector2ByPolarCoordinates(num5 - num, num3 * num2);
path.AddBezier(startPos.X, startPos.Y, vector.X, vector.Y, vector2.X, vector2.Y, endPos.X, endPos.Y);
path.AddBezier(endPos.X, endPos.Y + 1f, vector2.X, vector2.Y + 2f, vector.X, vector.Y + 2f, startPos.X, startPos.Y + 1f);
}
else
{
vector = startPos.GetRawVector2ByPolarCoordinates(num4 - num, num3 * num2);
vector2 = endPos.GetRawVector2ByPolarCoordinates(num5 + num, num3 * num2);
path.AddBezier(startPos.X, startPos.Y, vector.X, vector.Y, vector2.X, vector2.Y, endPos.X, endPos.Y);
path.AddBezier(endPos.X, endPos.Y - 1f, vector2.X, vector2.Y - 2f, vector.X, vector.Y - 2f, startPos.X, startPos.Y - 1f);
}
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush);
brush.Dispose();
geometry.Dispose();
if (isTriplet)
{
RawVector2 pos = new RawVector2(vector.X + ((vector2.X - vector.X) / 2f), vector.Y + ((vector2.Y - vector.Y) / 2f));
renderTarget.DrawTextLayout(writeFactory, "3", pos, "Consolas", 16f, Color.FromArgb((int)(color.A * 0.75f), color), TextAlignment.Center, ParagraphAlignment.Center, SharpDX.DirectWrite.FontStyle.Normal, FontWeight.ExtraBlack);
}
}
}
public RawVector2 Render(RawVector2 Pos)
{
Base.D2DRenderTarget.DrawTextLayout(Pos, Text, Base.Brushes.GetColor(Color), DrawTextOptions.None);
return(new RawVector2(Text.Metrics.Width, Text.Metrics.Height));
}
public static void DrawBezierLine(this RenderTarget renderTarget, RawVector2 pStart, RawVector2 pM1, RawVector2 pM2, RawVector2 pEnd, Color color, float strokeWidth, StrokeStyle strokeStyle, bool disposeStrokeStyle = true)
{
PointF[] pathPoints;
using (GraphicsPath path = new GraphicsPath())
{
path.AddBezier(pStart.X, pStart.Y, pM1.X, pM1.Y, pM2.X, pM2.Y, pEnd.X, pEnd.Y);
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.DrawGeometry(geometry, brush, strokeWidth, strokeStyle);
brush.Dispose();
geometry.Dispose();
}
if (disposeStrokeStyle && (strokeStyle != null))
{
strokeStyle.Dispose();
}
}
public void Render()
{
RawVector2 nextPos;
float cursorY;
lock (ScreenElementsLock) {
cursorY = Math.Min(TextElementsHeight, Screen.ScreenSize.Height - (ScrollMode ? 0 : Base.DefaultTextFormat.FontSize));
nextPos = new RawVector2(0, cursorY);
float skipSz = 0;
int x;
for (x = ScreenElements.Count - 1; skipSz < TextElementsScroll; x--)
{
skipSz += ScreenElements[x].RenderedElementSize.Y;
}
var diff = TextElementsScroll - skipSz;
nextPos.Y += diff;
while (nextPos.Y > 0 && x >= 0)
{
nextPos.Y -= ScreenElements[x].RenderedElementSize.Y;
ScreenElements[x].Render(nextPos);
x--;
}
}
TextLayout tl;
lock (CommandLock) {
tl = new TextLayout(
Base.DWFactory,
CommandPre + Command,
Base.DefaultTextFormat,
Screen.ScreenSize.Width,
Screen.ScreenSize.Height
);
Base.D2DRenderTarget.FillRectangle(new RawRectangleF(0, cursorY, tl.Metrics.Width, cursorY + tl.Metrics.Height), Base.Brushes.GetColor(Settings.Colors.Background));
Base.D2DRenderTarget.DrawTextLayout(
new RawVector2(0, cursorY),
tl,
Base.Brushes.GetColor(Settings.Colors.NormalText),
DrawTextOptions.Clip
);
}
if (DateTime.Now.Millisecond % 200 >= 100 && !Commands.Parser.CommandExecuting)
{
float x, y;
lock (CursorLock)
tl.HitTestTextPosition(Cursor + CommandPre.Length, new RawBool(false), out x, out y);
//x = tl.Metrics.WidthIncludingTrailingWhitespace;
Base.D2DRenderTarget.DrawLine(
new RawVector2(
x,
cursorY
),
new RawVector2(
x,
cursorY + Base.DefaultTextFormat.FontSize
),
Base.Brushes.GetColor(Settings.Colors.NormalText)
);
}
tl.Dispose();
if (SpecialCommandPending || ScrollMode)
{
StrokeStyleProperties ssp = new StrokeStyleProperties();
ssp.DashStyle = DashStyle.Dash;
ssp.DashOffset = 15.0f;
using (var ss = new StrokeStyle(Base.D2DFactory, ssp))
Base.D2DRenderTarget.DrawRectangle(Screen.ScreenRect, Base.Brushes.GetColor(ScrollMode ? ConsoleColor.DarkBlue : ConsoleColor.DarkRed), 3.0f, ss);
}
}
public override void stepStart()
{
float xSpeed = 0;
if (currentAction == PlayerAction.idle || !grounded)
{
float lx = Program.getAnalog(AnalogEnum.lx);
float ly = Program.getAnalog(AnalogEnum.ly);
float speed = maxSpeed;
//if(Math.Sqrt(lx * lx + ly * ly) < .5)
//{
// speed /= 2;
//}
switch (Program.leftStickState())
{
case (StickState.right):
xSpeed = speed;
break;
case (StickState.upRight):
xSpeed = speed;
break;
case (StickState.downRight):
xSpeed = speed / 2;
break;
case (StickState.left):
xSpeed = -speed;
break;
case (StickState.upLeft):
xSpeed = -speed;
break;
case (StickState.downLeft):
xSpeed = -speed / 2;
break;
case (StickState.up):
break;
case (StickState.down):
break;
default:
switch (Program.dpadStickState())
{
case (StickState.right):
xSpeed = speed;
break;
case (StickState.upRight):
xSpeed = speed;
break;
case (StickState.downRight):
xSpeed = speed / 2;
break;
case (StickState.left):
xSpeed = -speed;
break;
case (StickState.upLeft):
xSpeed = -speed;
break;
case (StickState.downLeft):
xSpeed = -speed / 2;
break;
case (StickState.up):
break;
case (StickState.down):
break;
default:
break;
}
break;
}
}
if (currentAction == PlayerAction.attacking)
{
if (actionFrame >= 0)
{
currentAction = PlayerAction.idle;
}
}
else if (currentAction == PlayerAction.idle)
{
if (Program.getButton(ButtonEnum.a) == ButtonState.pressed)
{
jump();
}
if (Program.getButton(ButtonEnum.x) == ButtonState.pressed)
{
attack();
}
}
if (jumpFrame > 0)
{
if (Program.getButton(ButtonEnum.a) != ButtonState.down && Program.getButton(ButtonEnum.a) != ButtonState.pressed)
{
jumpFrame = 0;
}
}
safeMove(xSpeed, ySpeed);
if (jumpFrame <= 0)
{
ySpeed += gravity;
}
ySpeed = Math.Min(ySpeed, maxFallSpeed);
if (distanceToFloor() > 0)
{
grounded = false;
}
else
{
jumpFrame = 0;
}
RawMatrix3x2 fullTransform = getFullTransform();
RawVector2 location = new RawVector2(fullTransform.M31, fullTransform.M32);
if (location.X != idealLocation.X || location.Y != idealLocation.Y)
{
Program.currentRoom.move(location.X - idealLocation.X, location.Y - idealLocation.Y);
}
base.stepStart();
}
private RawVector2 SnapToGrid(RawVector2 v)
{
return(new RawVector2(SnapToGridX(v.X), SnapToGridY(v.Y)));
}
