public ErrorInfo Run(IViewPort viewPortInterface)
{
var noChange = new NoDataChangeDeltaModel();
var viewPort = (ViewPort)viewPortInterface;
var model = viewPort.Model;
var token = viewPort.CurrentChange;
Run(model, token);
return(ErrorInfo.NoError);
}
public static void DrawGrid(IViewPort viewPort)
{
var colsStart = (int)Math.Floor(viewPort.ViewPortContentOffset.X / GridSpace);
var colsEnd = (int)Math.Ceiling((viewPort.ViewPortContentOffset.X + viewPort.ViewPortSize.Width) / GridSpace);
for (int i = colsStart; i < colsEnd; i++)
{
DrawCol(viewPort, colors.ElementAt(i % 10000), i);
}
}
public bool CanRun(IViewPort viewPortInterface)
{
// require that I have a tab with real data, not a search tab or a diff tab or something
if (!(viewPortInterface is ViewPort viewPort))
{
return(false);
}
// require that we fan find the specials table and that it's long enough
var token = new NoDataChangeDeltaModel();
var specialsAddress = viewPort.Model.GetAddressFromAnchor(token, -1, HardcodeTablesModel.SpecialsTable);
if (specialsAddress < 0 || specialsAddress > viewPort.Model.Count)
{
return(false);
}
var specials = viewPort.Model.GetNextRun(specialsAddress) as ITableRun;
if (specials == null)
{
return(false);
}
if (specials.ElementCount < 397)
{
return(false);
}
// require that this data actually supports this change
var model = viewPort.Model;
var gameCode = model.GetGameCode();
var(getTutorMove, canPokemonLearnTutorMove, _, _) = GetOffsets(gameCode);
if (getTutorMove < 0 || canPokemonLearnTutorMove < 0)
{
return(false);
}
// require that this data has a tutormoves and tutorcompatibility table, since we're messing with those
var tutormoves = model.GetAddressFromAnchor(token, -1, MoveTutors);
var tutorcompatibility = model.GetAddressFromAnchor(token, -1, TutorCompatibility);
if (tutormoves == Pointer.NULL || tutorcompatibility == Pointer.NULL)
{
return(false);
}
// if the patch has already been applied, you can't apply it again
if (viewPort.Model.GetNextRun(canPokemonLearnTutorMove + 0x20) is WordRun)
{
return(false);
}
return(true);
}
public void RemoveViewPort(IViewPort viewport)
{
_renderer.RemoveViewPort(viewport);
//lock (_viewports)
//{
// if(_viewports.ContainsKey(viewport) && _viewports[viewport].CurrentPhotoTexture!=null)
// {
// _viewports[viewport].CurrentPhotoTexture.Dispose();
// _viewports[viewport].CurrentPhotoTexture = null;
// }
// _viewports.Remove(viewport);
//}
}
private void DrawLabels(CGContext context, IViewPort viewPort, IYAxis yAxis, nfloat positionX, nfloat axisLineStart, nfloat axisLineEnd, TextStyle textStyle, List <Tuple <double, string> > labels)
{
foreach (var label in labels)
{
var labelY = yAxis.GetContentValue(label.Item1);
var viewPortPositionY = viewPort.DisplayPositionY((nfloat)labelY);
if (viewPortPositionY >= axisLineStart && viewPortPositionY <= axisLineEnd)
{
DrawLabel(context, label.Item2, new CGPoint(positionX, viewPortPositionY), textStyle);
}
}
}
private string ExtractBoatStatisticString(ReplayBoat b, IViewPort target, string name, DateTime time)
{
string speedString = name + ": ";
speedString = speedString + string.Format("{0:0.##}", b.TotalStatistics.GetValue <float>(name, time, target.StatisticUnitType));
if (target.StatisticUnitType == StatisticUnitType.metric)
{
speedString = speedString + " " + b.TotalStatistics.GetStatisticMetricUnit(typeof(float), name);
}
else if (target.StatisticUnitType == StatisticUnitType.standard)
{
speedString = speedString + " " + b.TotalStatistics.GetStatisticStandardUnit(typeof(float), name);
}
return(speedString);
}
public IEnumerable <double> ValuePositions(IAxis axis, IViewPort viewPort)
{
var visibleSourceRangeStart = axis.Min - (axis.Min % Step) - Step;
var visibleSourceRangeEnd = axis.Max - (axis.Max % Step) + Step;
var positions = new List <double>();
for (double i = visibleSourceRangeStart; i <= visibleSourceRangeEnd; i += Step)
{
positions.Add(i);
}
return(positions);
}
public ErrorInfo Run(IViewPort viewPortInterface)
{
var viewPort = (ViewPort)viewPortInterface;
var model = viewPort.Model;
var(getTutorMove, canPokemonLearnTutorMove, getTutorMove_Length, canPokemonLearnTutorMove_Length) = GetOffsets(viewPort);
var tutormoves = model.GetAddressFromAnchor(viewPort.CurrentChange, -1, MoveTutors);
var tutorcompatibility = model.GetAddressFromAnchor(viewPort.CurrentChange, -1, TutorCompatibility);
InsertRoutine_GetTutorMove(viewPort, getTutorMove, getTutorMove_Length);
InsertRoutine_CanPokemonLearnTutorMove(viewPort, canPokemonLearnTutorMove, canPokemonLearnTutorMove_Length);
CanRunChanged?.Invoke(this, EventArgs.Empty);
return(ErrorInfo.NoError);
}
public static int GetFirstVisibleSelectedAddress(IViewPort viewPort)
{
for (int y = 0; y < viewPort.Height; y++)
{
for (int x = 0; x < viewPort.Width; x++)
{
if (!viewPort.IsSelected(new Point(x, y)))
{
continue;
}
return(viewPort.DataOffset + y * viewPort.Width + x);
}
}
return(-1);
}
public static int GetLastVisibleSelectedAddress(IViewPort viewPort)
{
for (int y = viewPort.Height - 1; y >= 0; y--)
{
for (int x = viewPort.Width - 1; x >= 0; x--)
{
if (!viewPort.IsSelected(new Point(x, y)))
{
continue;
}
return(viewPort.DataOffset + y * viewPort.Width + x);
}
}
return(-1);
}
public bool CanRun(IViewPort viewPortInterface)
{
var noChange = new NoDataChangeDeltaModel();
var viewPort = viewPortInterface as ViewPort;
if (viewPort == null)
{
return(false);
}
var model = viewPort.Model;
ArrayRun get(string name) => model.GetNextRun(model.GetAddressFromAnchor(noChange, -1, name)) as ArrayRun;
var regional = get(HardcodeTablesModel.RegionalDexTableName);
var national = get(HardcodeTablesModel.NationalDexTableName);
var convert = get(HardcodeTablesModel.ConversionDexTableName);
if (regional is null || national is null || convert is null)
{
return(false);
}
if (regional.ElementContent.Count != 1 || national.ElementContent.Count != 1 || convert.ElementContent.Count != 1)
{
return(false);
}
if (regional.ElementCount != national.ElementCount || regional.ElementCount != convert.ElementCount)
{
return(false);
}
if (regional.ElementLength != 2 || national.ElementLength != 2 || convert.ElementLength != 2)
{
return(false);
}
for (int i = 0; i < regional.ElementCount; i++)
{
var regionalIndex = model.ReadMultiByteValue(regional.Start + i * 2, 2);
var nationalIndex = model.ReadMultiByteValue(national.Start + i * 2, 2);
var conversionIndex = model.ReadMultiByteValue(convert.Start + (regionalIndex - 1) * 2, 2);
if (nationalIndex != conversionIndex)
{
return(true);
}
}
return(false);
}
//public static IReadOnlyDictionary<string, int> GetNumberOfRelearnableMoves = new Dictionary<string, int> {
// { "AXVE0", 0x040574 },
// { "AXPE0", 0x040574 },
// { "AXVE1", 0x040594 },
// { "AXPE1", 0x040594 },
// { "BPRE0", 0x043E2C },
// { "BPGE0", 0x043E2C },
// { "BPRE1", 0x043E40 },
// { "BPGE1", 0x043E40 },
// { "BPEE0", 0x06e25c },
//};
//public static IReadOnlyDictionary<string, int[]> MaxLevelUpMoveCountLocations = new Dictionary<string, int[]> { // each of these stores the max number of level-up moves, minus 1
// { "AXVE0", new[] { 0x0404E8, 0x040556, 0x0406A4 } },
// { "AXPE0", new[] { 0x0404E8, 0x040556, 0x0406A4 } },
// { "AXVE1", new[] { 0x040508, 0x040576, 0x0406C4 } },
// { "AXPE1", new[] { 0x040508, 0x040576, 0x0406C4 } },
// { "BPRE0", new[] { 0x043DA0, 0x043E0E, 0x043F5C } },
// { "BPGE0", new[] { 0x043DA0, 0x043E0E, 0x043F5C } },
// { "BPRE1", new[] { 0x043DB4, 0x043E22, 0x043F70 } },
// { "BPGE1", new[] { 0x043DB4, 0x043E22, 0x043F70 } },
// { "BPEE0", new[] { 0x06E1D0, 0x06E23E, 0x06E38C } },
//};
public async Task <ErrorInfo> Run(IViewPort viewPortInterface)
{
var viewPort = (IEditableViewPort)viewPortInterface;
var model = viewPort.Model;
var token = viewPort.ChangeHistory.CurrentChange;
var parser = viewPort.Tools.CodeTool.Parser;
ErrorInfo error;
error = await ExpandMoveEffects(parser, viewPort, token, .5);
if (error.HasError)
{
return(error);
}
// update limiters for move names
error = ReplaceAll(parser, model, token,
new[] { "mov r0, #177", "lsl r0, r0, #1", "cmp r1, r0" },
new[] { "mov r0, #177", "lsl r0, r0, #9", "cmp r1, r0" });
if (error.HasError)
{
return(error);
}
await viewPort.UpdateProgress(.6);
// update max level-up moves from 20 to 40
await viewPort.UpdateProgress(.7);
// update levelup moves
var storeFreeSpaceBuffer = viewPort.Model.FreeSpaceBuffer;
viewPort.Model.FreeSpaceBuffer = 0;
using (new StubDisposable {
Dispose = () => viewPort.Model.FreeSpaceBuffer = storeFreeSpaceBuffer
}) {
ExpandLevelUpMoveData(viewPort.Model, token);
}
await viewPort.UpdateProgress(.8);
await ExpandLevelUpMoveCode(viewPort, token, .8, 1);
viewPort.Refresh();
return(ErrorInfo.NoError);
}
public static IViewPort New(VideoTypes videoType, IDisposableResource parent, Point2 location, Size2 size)
{
IViewPort api = null;
#if WIN32
if (videoType == VideoTypes.D3D9)
{
api = new D3D9.ViewPort(parent, location, size);
}
#endif
#if WIN32 || WINRT || WP8
if (videoType == VideoTypes.D3D11)
{
api = new D3D11.ViewPort(parent, location, size);
}
#endif
#if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
if (videoType == VideoTypes.OpenGL)
{
api = new OpenGL.ViewPort(parent, location, size);
}
#endif
#if XNA
if (videoType == VideoTypes.XNA)
{
api = new XNA.ViewPort(parent, location, size);
}
#endif
#if VITA
if (videoType == VideoTypes.Vita)
{
api = new Vita.ViewPort(parent, location, size);
}
#endif
if (api == null)
{
Debug.ThrowError("ViewPortAPI", "Unsuported InputType: " + videoType);
}
return(api);
}
public bool CanRun(IViewPort viewPort)
{
// this ViewPort must be editable
if (!(viewPort is IEditableViewPort editableViewPort))
{
return(false);
}
// the new levelup thumb code must exist
if (!File.Exists(ExpandLevelUpMovesCode))
{
return(false);
}
// we need tables for level-up moves, move names, move stats, and move effects
foreach (var table in new[] { LevelMovesTableName, MoveDataTable, MoveNamesTable, MoveEffectsTable })
{
if (viewPort.Model.GetTable(table) == null)
{
return(false);
}
}
// the expansion must not have been run yet
// easy way to check: if the move stats table has 2 bytes for the effect field, it's been tampered with
var moveStatsTable = viewPort.Model.GetTable(MoveDataTable);
if (moveStatsTable.ElementContent[0].Length != 1)
{
return(false);
}
// moves must be 2 bytes each
var levelMovesTable = viewPort.Model.GetTable(LevelMovesTableName);
var destination = levelMovesTable.ReadPointer(viewPort.Model, 0);
var pokemonMoves = viewPort.Model.GetNextRun(destination) as ITableRun;
if (pokemonMoves == null || pokemonMoves.ElementLength != 2)
{
return(false);
}
return(true);
}
private static void DrawCol(IViewPort viewPort, UIColor color, int collnumer)
{
color.SetFill();
var x = collnumer * GridSpace;
var rowStart = (int)Math.Floor(viewPort.ViewPortContentOffset.Y / GridSpace);
var rowEnd = (int)Math.Ceiling((viewPort.ViewPortContentOffset.Y + viewPort.ViewPortSize.Height) / GridSpace);
int y = 0;
for (int i = rowStart; i < rowEnd; i++)
{
y = i * GridSpace;
DrawPoint(viewPort, x, y);
}
}
public async Task <ErrorInfo> Run(IViewPort viewPort)
{
var viewModel = (IEditableViewPort)viewPort;
var model = viewModel.Model;
var levelUpMoveTable = model.GetTable(HardcodeTablesModel.LevelMovesTableName);
for (int i = 0; i < levelUpMoveTable.ElementCount; i++)
{
var destination = levelUpMoveTable.ReadPointer(model, i);
var moveset = (ITableRun)model.GetNextRun(destination);
var sortedMoves = moveset.Sort(model, moveset.ElementContent.Count - 1);
viewModel.ChangeHistory.CurrentChange.ChangeData(model, moveset.Start, sortedMoves);
await viewModel.UpdateProgress((double)i / levelUpMoveTable.ElementCount);
}
viewModel.ClearProgress();
viewModel.ChangeHistory.ChangeCompleted();
viewModel.Refresh();
return(ErrorInfo.NoError);
}
protected virtual void DrawLabels(CGContext context, IViewPort viewPort, IXAxis xAxis, nfloat axisLineStart, nfloat axisLineEnd, nfloat axisYPosition, TextStyle textStyle)
{
var visibleSourceRangeStart = Math.Floor(xAxis.GetSourceValue(viewPort.ViewPortContentOffset.X));
var visibleSourceRangeEnd = Math.Ceiling(xAxis.GetSourceValue(viewPort.ViewPortContentOffset.X + viewPort.ViewPortSize.Width));
var labels = new List <Tuple <double, string> >();
for (double i = visibleSourceRangeStart; i <= visibleSourceRangeEnd; i += Step)
{
var text = ValueFormatter(i);
if (!string.IsNullOrEmpty(text))
{
labels.Add(new Tuple <double, string>(i, text));
}
}
DrawLabels(context, viewPort, xAxis, axisYPosition, axisLineStart, axisLineEnd, textStyle, labels);
}
public virtual void DrawAxis(CGContext context, IViewPort viewPort, IYAxis yAxis)
{
var axisLineStart = viewPort.ViewPortInsets.Top;
var axisLineEnd = viewPort.ViewPortInsets.Top + viewPort.ViewPortSize.Height;
if (Style.GridStyle.ShouldDraw)
{
DrawGrid(context, viewPort, yAxis, axisLineStart, axisLineEnd, Style.GridStyle);
}
if (Style.Position.HasFlag(YAxisPosition.Left))
{
var leftAxisX = viewPort.ViewPortRect.Left + Style.AxisDrawOffset;
if (Style.LineStyle.ShouldDraw)
{
DrawAxisLine(context, new CGPoint(leftAxisX, axisLineStart), new CGPoint(leftAxisX, axisLineEnd), Style.LineStyle);
}
if (Style.TextStyle.ShouldDraw)
{
DrawLabels(context, viewPort, yAxis, axisLineStart, axisLineEnd, leftAxisX, Style.TextStyle);
}
}
if (Style.Position.HasFlag(YAxisPosition.Right))
{
var rightAxisX = viewPort.ViewPortRect.Right + Style.AxisDrawOffset;
if (Style.LineStyle.ShouldDraw)
{
DrawAxisLine(context, new CGPoint(rightAxisX, axisLineStart), new CGPoint(rightAxisX, axisLineEnd), Style.LineStyle);
}
if (Style.TextStyle.ShouldDraw)
{
DrawLabels(context, viewPort, yAxis, axisLineStart, axisLineEnd, rightAxisX, Style.TextStyle);
}
}
}
public bool CanRun(IViewPort viewPortInterface)
{
var viewPort = viewPortInterface as ViewPort;
if (viewPort == null)
{
return(false);
}
var model = viewPortInterface.Model;
var gameCode = model.GetGameCode();
var start = GetPrimaryEditAddress(gameCode);
if (start == -1)
{
return(false);
}
var run = model.GetNextRun(start);
return(!(run is WordRun));
}
public bool CanRun(IViewPort viewPortInterface)
{
var viewPort = viewPortInterface as ViewPort;
if (viewPort == null)
{
return(false);
}
var model = viewPortInterface.Model;
var gameCode = new string(Enumerable.Range(0xAC, 4).Select(i => ((char)model[i])).ToArray());
var start = GetPrimaryEditAddress(gameCode);
if (start == -1)
{
return(false);
}
var run = model.GetNextRun(start);
return(!(run is WordRun));
}
public bool CanRun(IViewPort viewPort)
{
if (!(viewPort is ViewPort))
{
return(false);
}
var model = viewPort.Model;
var moveDataAddress = model.GetAddressFromAnchor(new NoDataChangeDeltaModel(), -1, "movedata");
if (moveDataAddress == Pointer.NULL)
{
return(false);
}
var limiterCode = viewPort.Tools.CodeTool.Parser.Compile(model, 0, @"
mov r0, #177
lsl r0, r0, #1
cmp r1, r0
".Split(Environment.NewLine)).ToArray();
return(model.ThumbFind(limiterCode).Any());
}
public IEnumerable <double> ValuePositions(IAxis axis, IViewPort viewPort)
{
var axisLength = axis.Max - axis.Min;
if (axisLength == 0)
{
return new List <double> {
0D
}
}
;
var step = axisLength / Count;
var start = axis.Min;
if (RoundStep)
{
var mod = Mod ?? GetMod(step);
if (step > mod && step % mod != 0)
{
step -= step % mod;
}
if (axis.Min % mod != 0)
{
start -= axis.Min % mod + mod;
}
}
var positions = new List <double>();
for (double i = start; i <= axis.Max; i += step)
{
positions.Add(i);
}
return(positions);
}
public bool CanRun(IViewPort viewPort)
{
if (viewPort is not ViewPort)
{
return(false);
}
if (viewPort.Model.GetGameCode() != "BPRE0")
{
return(false);
}
var table = viewPort.Model.GetTable(HardcodeTablesModel.PokemonNameTable);
if (table == null || table.ElementCount != 412)
{
return(false);
}
if ((viewPort.Model.GetMatchedWords(PokemonCountConstant)?.Count ?? 0) > 0)
{
return(false);
}
return(true);
}
public bool CanRun(IViewPort viewPort)
{
if (!File.Exists(ExpandLevelUpMovesCode))
{
return(false);
}
if (!(viewPort is IEditableViewPort editableViewPort))
{
return(false);
}
var noChange = new NoDataChangeDeltaModel();
if (viewPort.Model.GetAddressFromAnchor(noChange, -1, LevelMovesTableName) == Pointer.NULL)
{
return(false);
}
if (viewPort.Model.GetAddressFromAnchor(noChange, -1, MoveDataTable) == Pointer.NULL)
{
return(false);
}
return(true);
}
public ErrorInfo Run(IViewPort viewPortInterface)
{
var viewPort = (ViewPort)viewPortInterface;
var model = viewPort.Model;
var gameCode = model.GetGameCode();
SplitTmsHms(viewPort);
InsertCanPokemonLearnTmOrHmMove(viewPort, gameCode);
InsertIsMoveHmMove2(viewPort, gameCode);
InsertReadBitArray(viewPort, gameCode);
InsertSpecial196(viewPort, gameCode);
InsertParseNumber(viewPort, gameCode);
InsertGetBattleMoveFromItemNumber(viewPort, gameCode);
InsertIsMoveHmMove1(viewPort, gameCode);
InsertIsItemTmHm(viewPort, gameCode);
InsertBufferTmHmNameForMenu(viewPort, gameCode);
InsertConvertItemPointerToTmHmBattleMoveId(viewPort, gameCode);
InsertIsItemTmHm2(viewPort, gameCode);
PatchItemRemovalFunctions(viewPort, gameCode);
CanRunChanged?.Invoke(this, EventArgs.Empty);
return(ErrorInfo.NoError);
}
protected virtual void DrawLabels(CGContext context, IViewPort viewPort, IYAxis yAxis, nfloat axisLineStart, nfloat axisLineEnd, nfloat axisXPosition, TextStyle textStyle)
{
var positions = AxisValuesPositionsProvider?.ValuePositions(yAxis, viewPort);
if (!positions?.Any() ?? false)
{
return;
}
var labels = new List <Tuple <double, string> >();
foreach (var item in positions)
{
var text = ValueFormatter(item);
if (!string.IsNullOrEmpty(text))
{
labels.Add(new Tuple <double, string>(item, text));
}
}
DrawLabels(context, viewPort, yAxis, axisXPosition, axisLineStart, axisLineEnd, textStyle, labels);
}
public ErrorInfo Run(IViewPort viewPortInterface)
{
var viewPort = (ViewPort)viewPortInterface;
var model = viewPort.Model;
var token = viewPort.CurrentChange;
var gameCode = model.GetGameCode();
var(getTutorMove, canPokemonLearnTutorMove, getTutorMove_Length, canPokemonLearnTutorMove_Length) = GetOffsets(gameCode);
var specialsAddress = model.GetAddressFromAnchor(token, -1, SpecialsTable);
var tutorSpecial = model.ReadPointer(specialsAddress + 397 * 4); // Emerald tutors is actually special 477, but we don't need to edit it so it doesn't matter.
tutorSpecial -= 1; // the pointer is to thumb code, so it's off by one.
var tutormoves = model.GetAddressFromAnchor(viewPort.CurrentChange, -1, MoveTutors);
var tutorcompatibility = model.GetAddressFromAnchor(viewPort.CurrentChange, -1, TutorCompatibility);
InsertRoutine_GetTutorMove(viewPort, getTutorMove, getTutorMove_Length);
InsertRoutine_CanPokemonLearnTutorMove(viewPort, canPokemonLearnTutorMove, canPokemonLearnTutorMove_Length);
UpdateRoutine_TutorSpecial(viewPort, tutorSpecial, gameCode);
CanRunChanged?.Invoke(this, EventArgs.Empty);
return(ErrorInfo.NoError);
}
public virtual void DrawAxis(CGContext context, IViewPort viewPort, IXAxis xAxis)
{
var axisLineStart = viewPort.ViewPortInsets.Left;
var axisLineEnd = viewPort.ViewPortInsets.Left + viewPort.ViewPortSize.Width;
if (Style.Position.HasFlag(XAxisPosition.Top))
{
var topLineY = viewPort.ViewPortRect.Top + Style.AxisDrawOffset;
if (Style.LineStyle.ShouldDraw)
{
DrawAxisLine(context, new CGPoint(axisLineStart, topLineY), new CGPoint(axisLineEnd, topLineY), Style.LineStyle);
}
if (Style.TextStyle.ShouldDraw)
{
DrawLabels(context, viewPort, xAxis, axisLineStart, axisLineEnd, topLineY, Style.TextStyle);
}
}
if (Style.Position.HasFlag(XAxisPosition.Bottom))
{
var bottomLineY = viewPort.ViewPortRect.Bottom + Style.AxisDrawOffset;
if (Style.LineStyle.ShouldDraw)
{
DrawAxisLine(context, new CGPoint(axisLineStart, bottomLineY), new CGPoint(axisLineEnd, bottomLineY), Style.LineStyle);
}
if (Style.TextStyle.ShouldDraw)
{
DrawLabels(context, viewPort, xAxis, axisLineStart, axisLineEnd, bottomLineY, Style.TextStyle);
}
}
}
protected virtual void InitMovement(IViewPort viewPort, CGPoint positionToMove)
{
link = CADisplayLink.Create(OnDisplayLinkLoop);
var positionToMoveOffset = positionToMove.Subtract(new CGPoint(viewPort.ViewPortSize.Width / 2, viewPort.ViewSize.Height / 2));
var moveDelta = positionToMoveOffset.Subtract(viewPort.ViewPortContentOffset);
decelerationVelocityX = 2D * moveDelta.X / MovementTime;
decelerationVelocityY = 2D * moveDelta.Y / MovementTime;
decelerationX = 2D * moveDelta.X / Math.Pow(MovementTime, 2);
decelerationY = 2D * moveDelta.Y / Math.Pow(MovementTime, 2);
lastDecelerationFramePositionX = 0;
lastDecelerationFramePositionY = 0;
decelerationStartTime = CAAnimation.CurrentMediaTime();
link.AddToRunLoop(NSRunLoop.Current, NSRunLoop.NSDefaultRunLoopMode);
}
public void AddViewPort(IViewPort viewport)
{
_renderer.AddViewPort(viewport);
//viewport.SetMaxSize(GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width, GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height);
//CameraMan man = new CameraMan();
//man.Camera = new Camera(_worldBounds);
//man.HorizontalRotation = 0f;
//man.VerticalRotation = (float)(Math.PI) + (((float)Math.PI) / 20f) + (((float)Math.PI) / 20f);
//man.Zoom = 10f;
//man.SelectedBoat = 0;
//man.DrawSatelliteImagery = _lakeTextureAvailible;
//viewport.CameraMan = man;
////List<string> boatNames = new List<string>();
////List<string> boatNumbers = new List<string>();
////List<System.Drawing.Color> boatColors = new List<System.Drawing.Color>();
////foreach (AmphibianSoftware.VisualSail.Library.Boat b in boats)
////{
//// boatNames.Add(b.Name);
//// boatNumbers.Add(b.Number);
//// boatColors.Add(b.Color);
////}
//Dictionary<AmphibianSoftware.VisualSail.Library.Boat, int> offsets = viewport.SetBoatList(_boats);
//viewport.Shutdown = new ShutdownViewPort(this.RemoveViewPort);
//lock (_viewports)
//{
// _viewports.Add(viewport, man);
//}
//lock (_viewportOffsets)
//{
// _viewportOffsets.Add(viewport, offsets);
//}
}
public void RemoveViewPort(IViewPort viewport)
{
_renderer.RemoveViewPort(viewport);
//lock (_viewports)
//{
// if(_viewports.ContainsKey(viewport) && _viewports[viewport].CurrentPhotoTexture!=null)
// {
// _viewports[viewport].CurrentPhotoTexture.Dispose();
// _viewports[viewport].CurrentPhotoTexture = null;
// }
// _viewports.Remove(viewport);
//}
}
public override void AddViewPort(IViewPort viewport)
{
GdiCameraMan man = new GdiCameraMan();
man.SelectedBoat = 0;
man.DrawSatelliteImagery = _lakeTextureAvailible;
viewport.CameraMan = man;
viewport.SetBoatList(this.Replay.Boats);
viewport.Shutdown = new ShutdownViewPort(this.RemoveViewPort);
lock (_viewports)
{
_viewports.Add(viewport, man);
}
lock (_buffers)
{
int bufferWidth = viewport.RenderTarget.Width;
int bufferHeight = viewport.RenderTarget.Height;
_buffers.Add(viewport, new Bitmap(bufferWidth, bufferHeight));
}
lock (_graphics)
{
_graphics.Add(viewport,Graphics.FromImage(_buffers[viewport]));
}
lock (_targetGraphics)
{
if (viewport.RenderTarget.IsHandleCreated)
{
_targetGraphics.Add(viewport, Graphics.FromHwnd(viewport.RenderTarget.Handle));
}
}
}
public override void RemoveViewPort(IViewPort viewport)
{
lock (_graphics)
{
_graphics.Remove(viewport);
}
lock (_buffers)
{
_buffers.Remove(viewport);
}
lock (_viewports)
{
_viewports.Remove(viewport);
}
}
//private CoordinatePoint.ProjectedPoint ProjectedPointFromWorld(Vector3 v)
//{
// CoordinatePoint.ProjectedPoint pp = new CoordinatePoint.ProjectedPoint();
// pp.northing = (v.X + _xOffset) * _coordinateDivisor;
// pp.easting = (v.Z + _zOffset) * _coordinateDivisor;
// pp.height = (v.Y * _coordinateDivisor);
// return pp;
//}
private string ExtractBoatStatisticString(ReplayBoat b, IViewPort target, string name, DateTime time)
{
string speedString = name + ": ";
speedString = speedString + string.Format("{0:0.##}", b.TotalStatistics.GetValue<float>(name, time, target.StatisticUnitType));
if (target.StatisticUnitType == StatisticUnitType.metric)
{
speedString = speedString + " " + b.TotalStatistics.GetStatisticMetricUnit(typeof(float), name);
}
else if (target.StatisticUnitType == StatisticUnitType.standard)
{
speedString = speedString + " " + b.TotalStatistics.GetStatisticStandardUnit(typeof(float), name);
}
return speedString;
}
public override void RemoveViewPort(IViewPort viewport)
{
}
public abstract void AddViewPort(IViewPort viewport);
public abstract void RemoveViewPort(IViewPort viewport);
private void Render(IViewPort target)
{
XnaCameraMan cameraMan = _viewports[target];
if (cameraMan.DrawSatelliteImagery && _lakeTextureAvailible)
{
_device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.White, 1.0f, 0);
}
else
{
_device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
}
if (this.Replay.Boats[_viewports[target].SelectedBoat].ProjectedPoint != null)
{
cameraMan.FollowBoat(ProjectedPointToWorld(this.Replay.Boats[_viewports[target].SelectedBoat].ProjectedPoint));
Camera camera = cameraMan.Camera;
camera.UpdatePosition();
camera.ConfigureBasicEffect(_instruments);
Viewport viewport = _device.Viewport;
if (target.RenderTarget.Height <= _device.PresentationParameters.BackBufferHeight)
{
viewport.Height = target.RenderTarget.Height;
}
else
{
viewport.Height = _device.PresentationParameters.BackBufferHeight;
}
if (target.RenderTarget.Width <= _device.PresentationParameters.BackBufferWidth)
{
viewport.Width = target.RenderTarget.Width;
}
else
{
viewport.Width = _device.PresentationParameters.BackBufferWidth;
}
viewport.X = 0;
viewport.Y = 0;
_device.Viewport = viewport;
if (cameraMan.DrawSatelliteImagery)
{
if (_lakeTextureAvailible)
{
VertexPositionTexture[] textureTris = new VertexPositionTexture[4];
textureTris[0] = new VertexPositionTexture(ProjectedPointToWorld(this.Race.Lake.TopLeftInMeters), new Vector2(0, 0));
textureTris[1] = new VertexPositionTexture(ProjectedPointToWorld(this.Race.Lake.BottomLeftInMeters), new Vector2(0, 1));
textureTris[2] = new VertexPositionTexture(ProjectedPointToWorld(this.Race.Lake.TopRightInMeters), new Vector2(1, 0));
textureTris[3] = new VertexPositionTexture(ProjectedPointToWorld(this.Race.Lake.BottomRightInMeters), new Vector2(1, 1));
textureTris[0].Position.Y = -0.5f;
textureTris[0].Position.Y = -0.5f;
textureTris[0].Position.Y = -0.5f;
textureTris[0].Position.Y = -0.5f;
camera.ConfigureBasicEffect(_lakeTextureEffect);
_lakeTextureEffect.World = Matrix.Identity;
_lakeTextureEffect.Begin();
foreach (EffectPass pass in _lakeTextureEffect.CurrentTechnique.Passes)
{
pass.Begin();
_device.VertexDeclaration = VertexDeclarationHelper.Get(typeof(VertexPositionTexture));
_device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleStrip, textureTris, 0, 2);
pass.End();
}
_lakeTextureEffect.End();
}
camera.ConfigureBasicEffect(_skyBoxEffect);
_skyBoxEffect.World = Matrix.Identity;
_skyBoxEffect.Begin();
foreach (EffectPass pass in _skyBoxEffect.CurrentTechnique.Passes)
{
pass.Begin();
_device.VertexDeclaration = VertexDeclarationHelper.Get(typeof(VertexPositionTexture));
_device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleStrip, _skybox, 0, 8);
pass.End();
}
_skyBoxEffect.End();
}
if (cameraMan.DrawGrid)
{
_instruments.World = Matrix.Identity;
_instruments.Begin();
foreach (EffectPass pass in _instruments.CurrentTechnique.Passes)
{
pass.Begin();
_device.VertexDeclaration = VertexDeclarationHelper.Get(typeof(VertexPositionColor));
_device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, _gridLines, 0, _gridLines.Length / 2);
pass.End();
}
_instruments.End();
}
Dictionary<ReplayBoat, Vector2> locations = new Dictionary<ReplayBoat, Vector2>();
foreach (ReplayBoat b in this.Replay.Boats)
{
DrawHUD(b,_device, cameraMan, this.Replay.SimulationTime, _coordinateDivisor);
if (cameraMan.ShowAnyIdentifiers || target.ClickedPoint != null || cameraMan.PhotoMode != CameraMan.PhotoDisplayMode.Disabled)
{
if (b.ProjectedPoint != null)
{
Vector3 twoD = viewport.Project(ProjectedPointToWorld(b.ProjectedPoint), camera.ProjectionMatrix, camera.ViewMatrix, Matrix.Identity);
if (twoD.Z < 1f)
{
locations.Add(b, new Vector2(twoD.X, twoD.Y));
}
}
}
}
foreach (ReplayBoat b in this.Replay.Boats)
{
DrawBoat(b,_device, cameraMan, this.Replay.SimulationTime);
}
Dictionary<Bouy, Vector2> bouyLocations = new Dictionary<Bouy, Vector2>();
foreach (Mark m in this.Replay.Race.Course.Marks)
{
foreach (Bouy b in m.Bouys)
{
DrawBouy(b, _device, camera);
if (cameraMan.ShowMarkNames)
{
Vector3 twoD = viewport.Project(ProjectedPointToWorld(b.CoordinatePoint.Project()), camera.ProjectionMatrix, camera.ViewMatrix, Matrix.Identity);
if (twoD.Z < 1f)
{
bouyLocations.Add(b, new Vector2(twoD.X, twoD.Y));
}
}
}
}
////course navigation debug lines
//List<VertexPositionColor> markRoundLines = new List<VertexPositionColor>();
//for (int i = 0; i < this.Race.Course.Route.Count; i++)
//{
// if (i > 0 && i < this.Race.Course.Route.Count - 1)
// {
// Vector3 a = ProjectedPointToWorld(this.Race.Course.Route[i].AveragedLocation.Project());
// Vector3 b = ProjectedPointToWorld(this.Race.Course.Route[i].FindMarkRoundPoint(this.Race.Course.Route[i - 1], this.Race.Course.Route[i + 1]));
// VertexPositionColor vpcA = new VertexPositionColor(a, Color.Red);
// VertexPositionColor vpcB = new VertexPositionColor(b, Color.Red);
// markRoundLines.Add(vpcA);
// markRoundLines.Add(vpcB);
// }
//}
//_instruments.World = Matrix.Identity;
//_instruments.Begin();
//foreach (EffectPass pass in _instruments.CurrentTechnique.Passes)
//{
// pass.Begin();
// _device.VertexDeclaration = VertexDeclarationHelper.Get(typeof(VertexPositionColor));
// _device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, markRoundLines.ToArray(), 0, markRoundLines.Count / 2);
// pass.End();
//}
//_instruments.End();
////end course navigation debug
DrawMouseInstructions(DateTime.Now - target.CreatedAt, viewport.Width, viewport.Height);
if (cameraMan.ShowAnyIdentifiers || cameraMan.ShowMarkNames || cameraMan.DrawPlaybackSpeed || cameraMan.PhotoMode != CameraMan.PhotoDisplayMode.Disabled)
{
_batch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);
List<BoundingBox> labelBoxBounds = new List<BoundingBox>();
//if (cameraMan.PhotoMode != CameraMan.PhotoDisplayMode.Disabled)
//{
// BoundingBox box = DrawPhoto(locations, target, cameraMan);
// if (box != default(BoundingBox))
// {
// labelBoxBounds.Add(box);
// }
//}
if (cameraMan.DrawPlaybackSpeed)
{
string playString = "";
if (Replay.Speed == 0 /*|| _play==false*/)
{
playString = "||";
}
else if (Replay.Speed == 1)
{
playString = ">";
}
else if (Replay.Speed > 1)
{
playString = ">> " + Replay.Speed + "x";
}
else if (Replay.Speed == -1)
{
playString = "<";
}
else if (Replay.Speed < -1)
{
playString = "<< " + Replay.Speed + "x";
}
else
{
playString = "?";
}
_batch.DrawString(_font, playString, new Vector2(50, 50), new Color(new Vector4(1, 1, 1, .75f)));
}
if (cameraMan.ShowAnyIdentifiers)
{
foreach (ReplayBoat b in locations.Keys)
{
Vector2 p = locations[b];
if (IsBoatOnScreen(p, target))
{
List<string> text = new List<string>();
string topRow = "";
if (cameraMan.ShowName)
{
topRow = topRow + b.Name;
}
if (cameraMan.ShowNumber)
{
topRow = topRow + " " + b.Number;
}
if (cameraMan.ShowPosition)
{
int pos = b.GetCurrentPosition(this.Replay.SimulationTime);
string v = VerbageHelper.PositionString(pos);
if (v.Length > 0)
{
topRow = topRow + " (" + v + ")";
}
}
if (topRow.Length > 0)
{
text.Add(topRow);
}
if (cameraMan.ShowSpeed)
{
text.Add(ExtractBoatStatisticString(b, target, "Speed", this.Replay.SimulationTime));
}
if (cameraMan.ShowVMGToCourse)
{
text.Add(ExtractBoatStatisticString(b, target, "VMG to Course", this.Replay.SimulationTime));
}
if (cameraMan.ShowDistanceToMark)
{
text.Add(ExtractBoatStatisticString(b, target, "Distance to Mark", this.Replay.SimulationTime));
}
if (cameraMan.ShowDistanceToCourse)
{
text.Add(ExtractBoatStatisticString(b, target, "Distance to Course", this.Replay.SimulationTime));
}
if (cameraMan.ShowAngleToMark)
{
text.Add(ExtractBoatStatisticString(b, target, "Angle to Mark", this.Replay.SimulationTime));
}
if (cameraMan.ShowAngleToWind)
{
text.Add(ExtractBoatStatisticString(b, target, "Angle to Wind", this.Replay.SimulationTime));
}
if (cameraMan.ShowAngleToCourse)
{
text.Add(ExtractBoatStatisticString(b, target, "Angle to Course", this.Replay.SimulationTime));
}
DrawLabelBox(p, _batch, new Color(b.Color.R, b.Color.G, b.Color.B, b.Color.A), text, ref labelBoxBounds, viewport.Width, viewport.Height);
}
}
}
if (cameraMan.ShowMarkNames)
{
foreach (Bouy b in bouyLocations.Keys)
{
Vector2 p = bouyLocations[b];
if (p.X > 0 && p.X < viewport.Width && p.Y > 0 && p.Y < viewport.Height)
{
List<string> text = new List<string>();
text.Add(b.Mark.Name);
DrawLabelBox(p, _batch, new Color(new Vector3(1, 0.5f, 0)), text, ref labelBoxBounds, viewport.Width, viewport.Height);
}
}
}
_batch.End();
}
if (target.ClickedPoint != null)
{
Vector2 clicked = new Vector2((float)target.ClickedPoint.Value.X, (float)target.ClickedPoint.Value.Y);
float minDistance = float.MaxValue;
int selectedIndex = -1;
for (int i = 0; i < locations.Keys.Count; i++)
{
float distance = Vector2.Distance(clicked, locations[locations.Keys.ElementAt(i)]);
if (distance < minDistance)
{
selectedIndex = i;
minDistance = distance;
}
}
if (minDistance < 25f)
{
target.SetSelectedBoatIndex(selectedIndex);
}
target.ClickedPoint = null;
}
try
{
//make sure we have a handle before we try and draw
if (target.HasHandle)
{
lock (target.RenderTarget)
{
_device.Present(new Rectangle(0, 0, _device.Viewport.Width, _device.Viewport.Height), new Rectangle(0, 0, _device.Viewport.Width, _device.Viewport.Height), target.RenderTarget.Handle);
}
}
else
{
throw new InvalidOperationException("No Handle");
}
}
catch (Exception)
{
//if the windows are being docked/undocked or similiar, the handle might get destroyed mid-draw
//it's ok if this happens, we'll just draw again on the next frame.
//this is hacky, but i can't find a better way to prevent or catch this issue
}
if (target.Record == RecorderState.Recording && _xnaAviWriter != null && _xnaAviWriter.Recording)
{
try
{
_xnaAviWriter.AddFrame();
}
catch
{
MessageBox.Show("The video codec or compression you selected is not compatible with VisualSail");
target.Record = RecorderState.Ready;
}
}
}
}
public override void RemoveViewPort(IViewPort viewport)
{
lock (_viewports)
{
if (_viewports.ContainsKey(viewport) && _viewports[viewport].CurrentPhotoTexture != null)
{
_viewports[viewport].CurrentPhotoTexture.Dispose();
_viewports[viewport].CurrentPhotoTexture = null;
}
_viewports.Remove(viewport);
}
}
public override void AddViewPort(IViewPort viewport)
{
viewport.SetMaxSize(GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width, GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height);
XnaCameraMan man = new XnaCameraMan(new Camera(_worldBounds),0f,(float)(Math.PI) + (((float)Math.PI) / 20f) + (((float)Math.PI) / 20f),10f);
man.SelectedBoat = 0;
man.DrawSatelliteImagery = _lakeTextureAvailible;
viewport.CameraMan = man;
//List<string> boatNames = new List<string>();
//List<string> boatNumbers = new List<string>();
//List<System.Drawing.Color> boatColors = new List<System.Drawing.Color>();
//foreach (AmphibianSoftware.VisualSail.Library.Boat b in boats)
//{
// boatNames.Add(b.Name);
// boatNumbers.Add(b.Number);
// boatColors.Add(b.Color);
//}
/*Dictionary<ReplayBoat, int> offsets = */
viewport.SetBoatList(this.Replay.Boats);
viewport.Shutdown = new ShutdownViewPort(this.RemoveViewPort);
lock (_viewports)
{
_viewports.Add(viewport, man);
}
//lock (_viewportOffsets)
//{
// _viewportOffsets.Add(viewport, offsets);
//}
}
public override void AddViewPort(IViewPort viewport)
{
}
private void Render(IViewPort target)
{
//get our cameraman
GdiCameraMan cameraMan = _viewports[target];
//check the buffer size, make sure it matches the window
//if not rebuild it
if ((target.RenderTarget.Height > 0 && target.RenderTarget.Width>0) && (target.RenderTarget.Width != _buffers[target].Width || target.RenderTarget.Height != _buffers[target].Height))
{
lock (_buffers)
{
_buffers[target].Dispose();
_buffers.Remove(target);
_buffers.Add(target, new Bitmap(target.RenderTarget.Width, target.RenderTarget.Height));
}
lock (_graphics)
{
_graphics[target].Dispose();
_graphics.Remove(target);
_graphics.Add(target, Graphics.FromImage(_buffers[target]));
}
if (target.RenderTarget.IsHandleCreated)
{
lock (_targetGraphics)
{
if (_targetGraphics[target] != null)
{
_targetGraphics[target].Dispose();
_targetGraphics.Remove(target);
}
_targetGraphics.Add(target, Graphics.FromHwnd(target.RenderTarget.Handle));
}
}
}
_graphics[target].Transform = new System.Drawing.Drawing2D.Matrix();
//clear the buffer to black
_graphics[target].Clear(Color.Black);
//_graphics[target].FillRectangle(Brushes.Black, 0, 0, _buffers[target].Width, _buffers[target].Height);
int xOffset = target.RenderTarget.Width / 2;
int yOffset = target.RenderTarget.Height / 2;
_graphics[target].TranslateTransform(xOffset, yOffset, System.Drawing.Drawing2D.MatrixOrder.Prepend);
_graphics[target].RotateTransform(cameraMan.Rotation, System.Drawing.Drawing2D.MatrixOrder.Prepend);
ReplayBoat boat=this.Replay.Boats[cameraMan.SelectedBoat];
if (boat.ProjectedPoint != null)
{
cameraMan.X = 0;
cameraMan.Y = 0;
cameraMan.FollowBoat(ProjectedPointToWorld(boat.ProjectedPoint, cameraMan));
}
float lakeX = ProjectedPointToWorld(Replay.Race.Lake.TopLeftInMeters,cameraMan).X;
float lakeY = ProjectedPointToWorld(Replay.Race.Lake.TopLeftInMeters,cameraMan).Y;
float lakeWidth = ProjectedPointToWorld(Replay.Race.Lake.BottomRightInMeters,cameraMan).X - lakeX;
float lakeHeight = ProjectedPointToWorld(Replay.Race.Lake.BottomRightInMeters,cameraMan).Y - lakeY;
_graphics[target].DrawImage(_lakeTexture, lakeX, lakeY, lakeWidth, lakeHeight);
DateTime lineStart = this.Replay.SimulationTime;
DateTime lineEnd = this.Replay.SimulationTime;
if (cameraMan.DrawFuturePath)
{
lineEnd = this.Replay.SimulationTime + new TimeSpan(0, 0, cameraMan.DrawPathLength);
}
if (cameraMan.DrawPastPath)
{
lineStart = this.Replay.SimulationTime - new TimeSpan(0, 0, cameraMan.DrawPathLength);
}
foreach (ReplayBoat b in this.Replay.Boats)
{
if (b.ProjectedPoint != null)
{
_graphics[target].FillRectangle(new SolidBrush(b.Color), ProjectedPointToWorld(b.ProjectedPoint,cameraMan).X-2, ProjectedPointToWorld(b.ProjectedPoint,cameraMan).Y-2, 4, 4);
if (cameraMan.DrawFuturePath || cameraMan.DrawPastPath)
{
var points = from pp in _boatTracks[b]
where pp.Key >= lineStart
&& pp.Key <= lineEnd
select pp.Value;
var projectedPoints = from pp in points
select ProjectedPointToWorld(pp, cameraMan);
var drawPoints = (from pp in projectedPoints
select new System.Drawing.Point((int)pp.X, (int)pp.Y)).ToArray();
_graphics[target].DrawLines(new Pen(new SolidBrush(b.Color)), drawPoints);
}
}
}
foreach (Mark mark in this.Replay.Race.Course.Marks)
{
foreach (Bouy bouy in mark.Bouys)
{
_graphics[target].FillRectangle(Brushes.Orange, ProjectedPointToWorld(bouy.CoordinatePoint.Project(),cameraMan).X - 2, ProjectedPointToWorld(bouy.CoordinatePoint.Project(),cameraMan).Y - 2, 4, 4);
}
}
_graphics[target].Flush();
_targetGraphics[target].DrawImage(_buffers[target], 0, 0);
_targetGraphics[target].Flush();
//Graphics targetGraphics = _targetGraphics[target];
//buffer.Save("C:\\test.bmp");
//targetGraphics.DrawImage(buffer, 0, 0);
// if (cameraMan.DrawGrid)
// {
// _instruments.World = Matrix.Identity;
// _instruments.Begin();
// foreach (EffectPass pass in _instruments.CurrentTechnique.Passes)
// {
// pass.Begin();
// _device.VertexDeclaration = VertexDeclarationHelper.Get(typeof(VertexPositionColor));
// _device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, _gridLines, 0, _gridLines.Length / 2);
// pass.End();
// }
// _instruments.End();
// }
// Dictionary<ReplayBoat, Vector2> locations = new Dictionary<ReplayBoat, Vector2>();
// foreach (ReplayBoat b in this.Replay.Boats)
// {
// DrawHUD(b, _device, cameraMan, this.Replay.SimulationTime, _coordinateDivisor);
// if (cameraMan.ShowAnyIdentifiers || target.ClickedPoint != null || cameraMan.PhotoMode != CameraMan.PhotoDisplayMode.Disabled)
// {
// if (b.ProjectedPoint != null)
// {
// Vector3 twoD = viewport.Project(b.ProjectedPoint.ToWorld(), camera.ProjectionMatrix, camera.ViewMatrix, Matrix.Identity);
// if (twoD.Z < 1f)
// {
// locations.Add(b, new Vector2(twoD.X, twoD.Y));
// }
// }
// }
// }
// foreach (ReplayBoat b in this.Replay.Boats)
// {
// DrawBoat(b, _device, cameraMan, this.Replay.SimulationTime);
// }
// Dictionary<Bouy, Vector2> bouyLocations = new Dictionary<Bouy, Vector2>();
// foreach (Mark m in this.Replay.Race.Course.Marks)
// {
// foreach (Bouy b in m.Bouys)
// {
// DrawBouy(b, _device, camera);
// if (cameraMan.ShowMarkNames)
// {
// Vector3 twoD = viewport.Project(b.CoordinatePoint.Project().ToWorld(), camera.ProjectionMatrix, camera.ViewMatrix, Matrix.Identity);
// if (twoD.Z < 1f)
// {
// bouyLocations.Add(b, new Vector2(twoD.X, twoD.Y));
// }
// }
// }
// }
// ////course navigation debug lines
// //List<VertexPositionColor> markRoundLines = new List<VertexPositionColor>();
// //for (int i = 0; i < this.Race.Course.Route.Count; i++)
// //{
// // if (i > 0 && i < this.Race.Course.Route.Count - 1)
// // {
// // Vector3 a = this.Race.Course.Route[i].AveragedLocation.Project().ToWorld();
// // Vector2 b2 = this.Race.Course.Route[i].FindMarkRoundPoint(this.Race.Course.Route[i - 1], this.Race.Course.Route[i + 1]);
// // Vector3 b = a;
// // b.X = b2.X;
// // b.Z = b2.Y;
// // VertexPositionColor vpcA = new VertexPositionColor(a, Color.Red);
// // VertexPositionColor vpcB = new VertexPositionColor(b, Color.Red);
// // markRoundLines.Add(vpcA);
// // markRoundLines.Add(vpcB);
// // }
// //}
// //instruments.World = Matrix.Identity;
// //instruments.Begin();
// //foreach (EffectPass pass in instruments.CurrentTechnique.Passes)
// //{
// // pass.Begin();
// // device.VertexDeclaration = VertexDeclarationHelper.Get(typeof(VertexPositionColor));
// // device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, markRoundLines.ToArray(), 0, markRoundLines.Count/2);
// // pass.End();
// //}
// //instruments.End();
// DrawMouseInstructions(DateTime.Now - target.CreatedAt, viewport.Width, viewport.Height);
// if (cameraMan.ShowAnyIdentifiers || cameraMan.ShowMarkNames || cameraMan.DrawPlaybackSpeed || cameraMan.PhotoMode != CameraMan.PhotoDisplayMode.Disabled)
// {
// _batch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);
// List<BoundingBox> labelBoxBounds = new List<BoundingBox>();
// //if (cameraMan.PhotoMode != CameraMan.PhotoDisplayMode.Disabled)
// //{
// // BoundingBox box = DrawPhoto(locations, target, cameraMan);
// // if (box != default(BoundingBox))
// // {
// // labelBoxBounds.Add(box);
// // }
// //}
// if (cameraMan.DrawPlaybackSpeed)
// {
// string playString = "";
// if (Replay.Speed == 0 /*|| _play==false*/)
// {
// playString = "||";
// }
// else if (Replay.Speed == 1)
// {
// playString = ">";
// }
// else if (Replay.Speed > 1)
// {
// playString = ">> " + Replay.Speed + "x";
// }
// else if (Replay.Speed == -1)
// {
// playString = "<";
// }
// else if (Replay.Speed < -1)
// {
// playString = "<< " + Replay.Speed + "x";
// }
// else
// {
// playString = "?";
// }
// _batch.DrawString(_font, playString, new Vector2(50, 50), new Color(new Vector4(1, 1, 1, .75f)));
// }
// if (cameraMan.ShowAnyIdentifiers)
// {
// foreach (ReplayBoat b in locations.Keys)
// {
// Vector2 p = locations[b];
// if (IsBoatOnScreen(p, target))
// {
// List<string> text = new List<string>();
// string topRow = "";
// if (cameraMan.ShowName)
// {
// topRow = topRow + b.Name;
// }
// if (cameraMan.ShowNumber)
// {
// topRow = topRow + " " + b.Number;
// }
// if (cameraMan.ShowPosition)
// {
// int pos = b.GetCurrentPosition(this.Replay.SimulationTime);
// string v = VerbageHelper.PositionString(pos);
// if (v.Length > 0)
// {
// topRow = topRow + " (" + v + ")";
// }
// }
// if (topRow.Length > 0)
// {
// text.Add(topRow);
// }
// if (cameraMan.ShowSpeed)
// {
// text.Add(ExtractBoatStatisticString(b, target, "Speed", this.Replay.SimulationTime));
// }
// if (cameraMan.ShowVMGToCourse)
// {
// text.Add(ExtractBoatStatisticString(b, target, "VMG to Course", this.Replay.SimulationTime));
// }
// if (cameraMan.ShowDistanceToMark)
// {
// text.Add(ExtractBoatStatisticString(b, target, "Distance to Mark", this.Replay.SimulationTime));
// }
// if (cameraMan.ShowDistanceToCourse)
// {
// text.Add(ExtractBoatStatisticString(b, target, "Distance to Course", this.Replay.SimulationTime));
// }
// if (cameraMan.ShowAngleToMark)
// {
// text.Add(ExtractBoatStatisticString(b, target, "Angle to Mark", this.Replay.SimulationTime));
// }
// if (cameraMan.ShowAngleToWind)
// {
// text.Add(ExtractBoatStatisticString(b, target, "Angle to Wind", this.Replay.SimulationTime));
// }
// if (cameraMan.ShowAngleToCourse)
// {
// text.Add(ExtractBoatStatisticString(b, target, "Angle to Course", this.Replay.SimulationTime));
// }
// DrawLabelBox(p, _batch, new Color(b.Color.R, b.Color.G, b.Color.B, b.Color.A), text, ref labelBoxBounds, viewport.Width, viewport.Height);
// }
// }
// }
// if (cameraMan.ShowMarkNames)
// {
// foreach (Bouy b in bouyLocations.Keys)
// {
// Vector2 p = bouyLocations[b];
// if (p.X > 0 && p.X < viewport.Width && p.Y > 0 && p.Y < viewport.Height)
// {
// List<string> text = new List<string>();
// text.Add(b.Mark.Name);
// DrawLabelBox(p, _batch, new Color(new Vector3(1, 0.5f, 0)), text, ref labelBoxBounds, viewport.Width, viewport.Height);
// }
// }
// }
// _batch.End();
// }
if (target.ClickedPoint != null)
{
Vector3 clicked = new Vector3((float)target.ClickedPoint.Value.X-xOffset, (float)target.ClickedPoint.Value.Y-yOffset,0f);
float minDistance = float.MaxValue;
int selectedIndex = -1;
for (int i = 0; i < Replay.Boats.Count; i++)
{
Vector3 boatLocation = ProjectedPointToWorld(Replay.Boats[i].ProjectedPoint, cameraMan);
float distance = Vector3.Distance(clicked, boatLocation);
if (distance < minDistance)
{
selectedIndex = i;
minDistance = distance;
}
}
if (minDistance < 25f)
{
target.SetSelectedBoatIndex(selectedIndex);
}
target.ClickedPoint = null;
}
// try
// {
// //make sure we have a handle before we try and draw
// if (target.HasHandle)
// {
// lock (target.RenderTarget)
// {
// _device.Present(new Rectangle(0, 0, _device.Viewport.Width, _device.Viewport.Height), new Rectangle(0, 0, _device.Viewport.Width, _device.Viewport.Height), target.RenderTarget.Handle);
// }
// }
// else
// {
// throw new InvalidOperationException("No Handle");
// }
// }
// catch (Exception)
// {
// //if the windows are being docked/undocked or similiar, the handle might get destroyed mid-draw
// //it's ok if this happens, we'll just draw again on the next frame.
// //this is hacky, but i can't find a better way to prevent or catch this issue
// }
// if (target.Record == RecorderState.Recording && _xnaAviWriter != null && _xnaAviWriter.Recording)
// {
// try
// {
// _xnaAviWriter.AddFrame();
// }
// catch
// {
// MessageBox.Show("The video codec or compression you selected is not compatible with VisualSail");
// target.Record = RecorderState.Ready;
// }
// }
//}
}
protected virtual void Draw(CGContext context, IEnumerable <IPointEntry> entries, IEnumerable <IPointEntry> highlightedEntries, IViewPort viewPort, IXAxis xAxis, IYAxis yAxis, PointRenderStyle renderStyle)
{
var points = entries
?.Select(t => new
{
Point = GetDrawPosition(t.X, t.Y, viewPort, xAxis, yAxis),
IsHighlight = highlightedEntries?.Contains(t) ?? false,
Entry = t
})
.ToList();
if (points != null)
{
context.SaveState();
context.ClipToRect(viewPort.ViewPortRect);
if (renderStyle.LineStyle.ShouldDraw)
{
DrawLine(context, points.Select(t => t.Point).ToList(), renderStyle);
}
if (renderStyle.MarkerStyle.ShouldDraw)
{
DrawNotHighlightedMarkers(context, points.Where(t => !t.IsHighlight).Select(t => t.Point).ToList(), renderStyle.MarkerStyle);
}
if (renderStyle.HighlightMarkerStyle.ShouldDraw)
{
DrawHighlightedMarkers(context, points.Where(t => t.IsHighlight).Select(t => t.Point).ToList(), renderStyle.HighlightMarkerStyle);
}
foreach (var point in points)
{
if (ShouldDraw(point.IsHighlight, renderStyle.TextStyle, renderStyle.HighlightTextStyle))
{
DrawEntryValue(context, point.Entry, point.Point, point.IsHighlight ? renderStyle.HighlightTextStyle : renderStyle.TextStyle);
}
}
context.RestoreState();
}
}
private bool IsBoatOnScreen(Vector2 b, IViewPort vp)
{
return (b.X > 0 && b.X < vp.RenderTarget.Width && b.Y > 0 && b.Y < vp.RenderTarget.Height);
}
