public Rectangle ToRectangle()
{
var width = Right - Left;
var height = Bottom - Top;
return(new Rectangle(MathHelperEx.Round(Left), MathHelperEx.Round(Top), MathHelperEx.Round(width), MathHelperEx.Round(height)));
}
public override RibbonParameters GetHoldRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var tp1 = NoteAnimationHelper.CalculateNoteTimePoints(startNote, animationMetrics);
var tp2 = NoteAnimationHelper.CalculateNoteTimePoints(endNote, animationMetrics);
var t1 = GetTransformedTime(startNote, now, tp1);
var t2 = GetTransformedTime(endNote, now, tp2);
var tperc = startNote.IsHold() ? 0.5 : 0.4;
var tm = MathHelperEx.Lerp(t1, t2, tperc);
var x1 = GetNoteX(startNote, now, noteMetrics, animationMetrics);
var x2 = GetNoteX(endNote, now, noteMetrics, animationMetrics);
var startStatus = NoteAnimationHelper.GetOnStageStatusOf(startNote, now, tp1);
float y1;
if (startStatus == OnStageStatus.Passed)
{
y1 = animationMetrics.Bottom;
}
else
{
y1 = GetNoteOnStageY(t1, animationMetrics);
}
var endStatus = NoteAnimationHelper.GetOnStageStatusOf(endNote, now, tp2);
float y2;
if (endStatus == OnStageStatus.Incoming)
{
y2 = animationMetrics.Top;
}
else
{
y2 = GetNoteOnStageY(t2, animationMetrics);
}
// CGSS-like
//var xm = GetNoteOnStageX(endNote.StartX, endNote.EndX, tm, animationMetrics);
// Naive guess
//var xm = (x1 + x2) / 2;
var xm = MathHelperEx.Lerp(x1, x2, 0.5f);
if (startNote.IsSlide())
{
if (endNote.EndX < startNote.EndX)
{
xm -= animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
}
else if (endNote.EndX > startNote.EndX)
{
xm += animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
}
}
var ym = GetNoteOnStageY(tm, animationMetrics);
var(cx1, cx2) = GetBezierFromQuadratic(x1, xm, x2);
var(cy1, cy2) = GetBezierFromQuadratic(y1, ym, y2);
return(new RibbonParameters(x1, y1, cx1, cy1, cx2, cy2, x2, y2));
}
public override float GetNoteY(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var timePoints = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
var onStageStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, timePoints);
float y;
switch (onStageStatus)
{
case OnStageStatus.Incoming:
y = animationMetrics.Top;
break;
case OnStageStatus.Visible:
y = MathHelperEx.Lerp(animationMetrics.Top, animationMetrics.Bottom, (now - timePoints.Enter) / timePoints.Duration);
break;
case OnStageStatus.Passed:
y = animationMetrics.Bottom;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(y);
}
private void SocketServer_NewMessage1Event(Socket socket, string Message)
{
try
{
SimpleLogHelper.Instance.WriteLog(LogType.Info, Message);
if (Message.Length != 24)
{
return;
}
AddLog("PLC数据请求" + Message);
ModbusTcpServer modbusTcpServer = new ModbusTcpServer();
modbusTcpServer.AffairID = Message.Substring(0, 4);
modbusTcpServer.ProtocolID = Message.Substring(4, 4);
int requestDataLength = MathHelper.HexToDec(Message.Substring(Message.Length - 4, 4)); //请求数据长度
modbusTcpServer.BackDataLength = MathHelper.DecToHex((requestDataLength * 2).ToString()).PadLeft(2, '0');
modbusTcpServer.SlaveId = Message.Substring(12, 2);
modbusTcpServer.Length = MathHelper.DecToHex((3 + requestDataLength * 2).ToString()).PadLeft(4, '0');
string backdata = modbusTcpServer.AffairID + modbusTcpServer.ProtocolID + modbusTcpServer.Length + modbusTcpServer.SlaveId + ModbusFunction.ReadHoldingRegisters + modbusTcpServer.BackDataLength;
string chengxuhao = ini.ReadIni("Request", "Index");
if (string.IsNullOrEmpty(chengxuhao))
{
chengxuhao = "0";
}
chengxuhao = MathHelper.DecToHex(chengxuhao).PadLeft(4, '0');
string xinghao = MathHelperEx.StrToASCII1(ini.ReadIni("Request", "ModelNum"));
string xinghaolength = MathHelper.DecToHex((ini.ReadIni("Request", "ModelNum").Length * 2).ToString()).PadLeft(4, '0');
backdata += (chengxuhao + xinghaolength + xinghao).PadRight(104, 'F');
string wuliaobianhao = MathHelperEx.StrToASCII1(ini.ReadIni("Request", "WuLiaoBianHao"));
string wuliaobianhaolength = MathHelper.DecToHex((ini.ReadIni("Request", "WuLiaoBianHao").Length * 2).ToString()).PadLeft(4, '0');
backdata += (wuliaobianhaolength + wuliaobianhao).PadRight(100, 'F');
if (this.socketServer.IsConnected(this.socketClient))
{
characterConversion = new CharacterConversion();
this.socketServer.Send(this.socketClient, characterConversion.HexConvertToByte(backdata));
AddLog("返回PLC数据：" + backdata);
CopyMesToPlc();
}
this.LinkToPlcTimer.Start();
Dispatcher.BeginInvoke(new Action(() =>
{
this.PlcState.Source = ConnectResult.Success;
}));
}
catch
{
AddLog("PLC请求数据失败");
this.LinkToPlcTimer.Start();
Dispatcher.BeginInvoke(new Action(() =>
{
this.PlcState.Source = ConnectResult.Fail;
}));
}
}
public static Vector2 CubicBezier(RibbonParameters rp, float t)
{
if (rp.IsLine)
{
throw new ArgumentException("You cannot calculate cubic Bezier curves for a linear ribbon.", nameof(rp));
}
var pt = MathHelperEx.CubicBezier(rp.X1, rp.Y1, rp.ControlX1, rp.ControlY1, rp.ControlX2, rp.ControlY2, rp.X2, rp.Y2, t);
return(new Vector2(pt.X, pt.Y));
}
public override RibbonParameters GetSlideRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var tp1 = NoteAnimationHelper.CalculateNoteTimePoints(startNote, animationMetrics);
var thisStatus = NoteAnimationHelper.GetOnStageStatusOf(startNote, now, tp1);
if (thisStatus < OnStageStatus.Passed)
{
return(GetHoldRibbonParameters(startNote, endNote, now, noteMetrics, animationMetrics));
}
var tp2 = NoteAnimationHelper.CalculateNoteTimePoints(endNote, animationMetrics);
var t1 = GetTransformedTime(startNote, now, tp1);
var t2 = GetTransformedTime(endNote, now, tp2);
var tperc = startNote.IsHold() ? 0.5 : 0.4;
var tm = MathHelperEx.Lerp(t1, t2, tperc);
var trackCount = animationMetrics.TrackCount;
var leftMarginRatio = animationMetrics.NoteEndXRatios[0];
var rightMarginRatio = animationMetrics.NoteEndXRatios[trackCount - 1];
var startXRatio = leftMarginRatio + (rightMarginRatio - leftMarginRatio) * (startNote.EndX / (trackCount - 1));
var endXRatio = leftMarginRatio + (rightMarginRatio - leftMarginRatio) * (endNote.EndX / (trackCount - 1));
var perc = (now - startNote.HitTime) / (endNote.HitTime - startNote.HitTime);
var x1Ratio = MathHelperEx.Lerp(startXRatio, endXRatio, perc);
var x1 = animationMetrics.Width * x1Ratio;
var y1 = animationMetrics.Bottom;
var x2 = GetNoteX(endNote, now, noteMetrics, animationMetrics);
var y2 = GetNoteOnStageY(t2, animationMetrics);
// CGSS-like
//var xm = GetNoteOnStageX(endNote.StartX, endNote.EndX, tm, animationMetrics);
// Naive guess
//var xm = (x1 + x2) / 2;
var xm = MathHelperEx.Lerp(x1, x2, 0.5f);
if (startNote.IsSlide())
{
if (endNote.EndX < startNote.EndX)
{
xm -= animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
}
else if (endNote.EndX > startNote.EndX)
{
xm += animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
}
}
var ym = GetNoteOnStageY(tm, animationMetrics);
var(cx1, cx2) = GetBezierFromQuadratic(x1, xm, x2);
var(cy1, cy2) = GetBezierFromQuadratic(y1, ym, y2);
return(new RibbonParameters(x1, y1, cx1, cy1, cx2, cy2, x2, y2));
}
private static float GetIncomingNoteXRatio([NotNull] RuntimeNote prevNote, RuntimeNote thisNote, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var trackCount = animationMetrics.TrackCount;
var trackXRatioStart = animationMetrics.NoteEndXRatios[0];
var trackXRatioEnd = animationMetrics.NoteEndXRatios[trackCount - 1];
var thisXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (prevNote.EndX / (trackCount - 1));
var nextXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (thisNote.EndX / (trackCount - 1));
var thisTimePoints = NoteAnimationHelper.CalculateNoteTimePoints(prevNote, animationMetrics);
var nextTimePoints = NoteAnimationHelper.CalculateNoteTimePoints(thisNote, animationMetrics);
var perc = (now - thisTimePoints.Enter) / (nextTimePoints.Enter - thisTimePoints.Enter);
return(MathHelperEx.Lerp(thisXRatio, nextXRatio, perc));
}
public override float GetNoteX(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var trackCount = animationMetrics.TrackCount;
var trackXRatioStart = animationMetrics.NoteEndXRatios[0];
var trackXRatioEnd = animationMetrics.NoteEndXRatios[trackCount - 1];
var endXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (note.EndX / (trackCount - 1));
var onStage = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
float xRatio;
switch (onStage)
{
case OnStageStatus.Incoming:
if (note.HasPrevHold())
{
xRatio = GetIncomingNoteXRatio(note.PrevHold, note, now, noteMetrics, animationMetrics);
}
else if (note.HasPrevSlide())
{
xRatio = GetIncomingNoteXRatio(note.PrevSlide, note, now, noteMetrics, animationMetrics);
}
else
{
xRatio = endXRatio;
}
break;
case OnStageStatus.Passed when note.HasNextSlide():
var destXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (note.NextSlide.EndX / (trackCount - 1));
var nextPerc = (now - note.HitTime) / (note.NextSlide.HitTime - note.HitTime);
xRatio = MathHelperEx.Lerp(endXRatio, destXRatio, nextPerc);
break;
default:
xRatio = endXRatio;
break;
}
return(animationMetrics.Width * xRatio);
}
private static float GetIncomingNoteXRatio(RuntimeNote prevNote, RuntimeNote thisNote, float now, NoteAnimationMetrics animationMetrics)
{
var trackCount = animationMetrics.TrackCount;
var startLeftMarginRatio = animationMetrics.NoteStartXRatios[0];
var startRightMarginRatio = animationMetrics.NoteStartXRatios[trackCount - 1];
float xRatio;
if (thisNote.IsSlide())
{
var thisXRatio = startLeftMarginRatio + (startRightMarginRatio - startLeftMarginRatio) * (prevNote.EndX / (trackCount - 1));
var nextXRatio = startLeftMarginRatio + (startRightMarginRatio - startLeftMarginRatio) * (thisNote.EndX / (trackCount - 1));
var thisTimePoints = NoteAnimationHelper.CalculateNoteTimePoints(prevNote, animationMetrics);
var nextTimePoints = NoteAnimationHelper.CalculateNoteTimePoints(thisNote, animationMetrics);
var perc = (now - thisTimePoints.Enter) / (nextTimePoints.Enter - thisTimePoints.Enter);
xRatio = MathHelperEx.Lerp(thisXRatio, nextXRatio, perc);
}
else
{
float nextStartX;
if (thisNote.StartX < 0)
{
nextStartX = thisNote.StartX * 0.5f;
}
else if (thisNote.StartX > trackCount - 1)
{
nextStartX = (trackCount - 1) + (thisNote.StartX - (trackCount - 1)) * 0.5f;
}
else
{
nextStartX = thisNote.StartX;
}
xRatio = startLeftMarginRatio + (startRightMarginRatio - startLeftMarginRatio) * (nextStartX / (trackCount - 1));
}
return(xRatio);
}
public override Vector2 GetNoteRadius(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var timePoints = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
var onStageStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, timePoints);
switch (onStageStatus)
{
case OnStageStatus.Incoming:
return(noteMetrics.StartRadius);
case OnStageStatus.Visible:
var passed = now - timePoints.Enter;
var perc = passed / timePoints.Duration;
var w = MathHelperEx.Lerp(noteMetrics.StartRadius.X, noteMetrics.EndRadius.X, perc);
var h = MathHelperEx.Lerp(noteMetrics.StartRadius.Y, noteMetrics.EndRadius.Y, perc);
return(new Vector2(w, h));
case OnStageStatus.Passed:
return(noteMetrics.EndRadius);
default:
throw new ArgumentOutOfRangeException();
}
}
public override float GetNoteX(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
{
var trackCount = animationMetrics.TrackCount;
var endLeftMarginRatio = animationMetrics.NoteEndXRatios[0];
var endRightMarginRatio = animationMetrics.NoteEndXRatios[trackCount - 1];
var endXRatio = endLeftMarginRatio + (endRightMarginRatio - endLeftMarginRatio) * (note.EndX / (trackCount - 1));
var onStage = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
float xRatio;
switch (onStage)
{
case OnStageStatus.Incoming:
if (note.HasPrevHold())
{
xRatio = GetIncomingNoteXRatio(note.PrevHold, note, now, animationMetrics);
}
else if (note.HasPrevSlide())
{
xRatio = GetIncomingNoteXRatio(note.PrevSlide, note, now, animationMetrics);
}
else
{
xRatio = endXRatio;
}
break;
case OnStageStatus.Passed:
if (note.HasNextSlide())
{
var destXRatio = endLeftMarginRatio + (endRightMarginRatio - endLeftMarginRatio) * (note.NextSlide.EndX / (trackCount - 1));
var nextPerc = (now - note.HitTime) / (note.NextSlide.HitTime - note.HitTime);
xRatio = MathHelperEx.Lerp(endXRatio, destXRatio, nextPerc);
}
else
{
xRatio = endXRatio;
}
break;
default:
var startLeftMarginRatio = animationMetrics.NoteStartXRatios[0];
var startRightMarginRatio = animationMetrics.NoteStartXRatios[trackCount - 1];
float whichStartToTake;
if (note.IsSlide())
{
whichStartToTake = note.EndX;
}
else
{
if (note.StartX < 0)
{
whichStartToTake = note.StartX * 0.5f;
}
else if (note.StartX > trackCount - 1)
{
whichStartToTake = (trackCount - 1) + (note.StartX - (trackCount - 1)) * 0.5f;
}
else
{
whichStartToTake = note.StartX;
}
}
var startXRatio = startLeftMarginRatio + (startRightMarginRatio - startLeftMarginRatio) * (whichStartToTake / (trackCount - 1));
var timePoints = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
var perc = (now - timePoints.Enter) / timePoints.Duration;
xRatio = MathHelperEx.Lerp(startXRatio, endXRatio, perc);
break;
}
return(animationMetrics.Width * xRatio);
}
public static Rectangle RoundToRectangle(float x, float y, float width, float height)
{
return(new Rectangle(MathHelperEx.Round(x), MathHelperEx.Round(y), MathHelperEx.Round(width), MathHelperEx.Round(height)));
}
