float i = 0; // DBG
private void Canvas_Update(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedUpdateEventArgs args)
{
// Speed for Elipse gradient
if (i < 0.5f)
{
i += 0.03f;
}
else if (i > 0.5f && i < 2.0f)
{
i += 0.05f;
}
else if (i > 1.0f && i < 2.0f)
{
i += 0.1f;
}
else
{
i += 0.1f;
}
linearGradientBrush.StartPoint = new Vector2(i - 0.1f, 1);
linearGradientBrush.EndPoint = new Vector2(i + 0.2f, 1);
if (i >= 14.0f)
{
i = 0f;
}
}
private void LcdScreen_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender,
Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (isLoaded)
{
args.DrawingSession.Clear(Color.FromArgb(255, 220, 220, 220));
visualizer.Draw(sender, args, gameStateMachine.StateCode);
args.DrawingSession.DrawText("Score: " + score.ToString().PadLeft(9, '0'),
new System.Numerics.Vector2(0f, 0f),
Color.FromArgb(255, 0, 0, 0));
args.DrawingSession.DrawText("Chances Left: " + chancesLeft.ToString(),
new System.Numerics.Vector2(0f, 50f),
Color.FromArgb(255, 0, 0, 0));
if (playerMessage != null)
{
args.DrawingSession.DrawText(playerMessage,
new System.Numerics.Vector2(0f, 100f),
Color.FromArgb((byte)messageFadeOpacity, 0, 0, 0));
}
if (playerMessageRow2 != null)
{
args.DrawingSession.DrawText(playerMessageRow2,
new System.Numerics.Vector2(0f, 120f),
Color.FromArgb((byte)messageFadeOpacity, 0, 0, 0));
}
}
}
private void canvasControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
var time = DateTime.Now;
var session = args.DrawingSession;
session.Clear(Colors.Transparent);
var width = 36f;
var radius = width * 0.45f;
var xCenter = (float)width / 2;
var yCenter = (float)width / 2;
session.DrawEllipse(xCenter, yCenter, radius, radius, Colors.Black, 2f);
session.FillCircle(xCenter, yCenter, radius, Colors.BlueViolet);
session.DrawEllipse(xCenter, yCenter, 1, 1, Colors.Black, 2f);
var secAngl = (time.Second + (time.Millisecond / 1000f)) * 6f;
var minAngl = (time.Minute * 6f) + secAngl / 60f;
var hourAngl = (time.Hour % 12 * 30f) + minAngl / 12f;
Action <float, double, float> drawline = (angle, length, lineWidth) =>
{
var radAng = (Math.PI / 180) * angle;
var x = xCenter + (Math.Cos(radAng) * length);
var y = yCenter + (Math.Sin(radAng) * length);
session.DrawLine(xCenter, yCenter, (int)x, (int)y, Colors.Black, lineWidth);
};
drawline(secAngl - 90, radius * 0.8, 1);
drawline(minAngl - 90, radius * 0.9, 2);
drawline(hourAngl - 90, radius * 0.5, 2.5f);
canvasControl.Invalidate();
}
private void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
foreach (var line in segments)
{
args.DrawingSession.DrawLine(line.StartPoint, line.EndPoint, brush, 3f);
}
}
private void LcdScreen_Update(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender,
Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedUpdateEventArgs args)
{
if (gameStateMachine.StateCode != GameStateCodes.GameOver)
{
int msElapsed = args.Timing.ElapsedTime.Milliseconds;
int playerLocationId = locationContainer.PlayerLocationId;
if (gameStateMachine.StateCode == StateMachine.GameStateCodes.Playing && playerVulnerable)
{
if (locationContainer.IsBugAt(playerLocationId))
{
playerVulnerable = false;
chancesLeft--;
gameStateMachine.Die(chancesLeft, 1000);
}
}
gameStateMachine.Update(msElapsed);
visualizer.Update(gameStateMachine.StateCode, msElapsed);
locationContainer.Update(msElapsed);
userInput.Update(msElapsed);
if (playerMessage != null)
{
messageFadeOpacity -= MessageFadeStep;
if (messageFadeOpacity <= MinMessageFadeOpacity)
{
messageFadeOpacity = MinMessageFadeOpacity;
playerMessage = null;
playerMessageRow2 = null;
}
}
}
}
private async void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (SharedMethods.isRunnnig)
{
var curDistance = SharedMethods.RoundTripDistance(tourLocations, tourOrder);
bestTourDistance = curDistance;
tourOrder = SimulatedAnnealing.PerformSimulatedAnnealing(tourOrder, Temperature, random);
Temperature = Temperature * TemperatureRate;
UpdateUI();
count++;
SharedMethods.DrawPath(args.DrawingSession, tourLocations, tourOrder, Color.FromArgb(85, 255, 255, 255), 2f);
}
else
{
if (count > 0)
{
SharedMethods.DrawPath(args.DrawingSession, tourLocations, tourOrder, Color.FromArgb(85, 255, 255, 255), 4f);
}
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
startBtn.Visibility = Visibility.Visible;
stopBtn.Visibility = Visibility.Collapsed;
});
sender.Paused = true;
}
}
private void DrawCanvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
Core mainCore = Core.MainCore;
if (mainCore != null && !mainCore.Running)
{
return;
}
var session = args.DrawingSession;
session.FillCircle(mainCore.Ball.Position, 20, Colors.Red);
session.FillCircle((float)sender.Size.Width, (float)sender.Size.Height, 20, Colors.Red);
session.DrawLine(new Vector2(200, 200), mainCore.Ball.Position / 10, Colors.Blue);
session.DrawText(
mainCore.Ball.Position.X.ToString() + "\n"
+ mainCore.Ball.Position.Y.ToString() + "\n"
+ mainCore.Ball.Acceleration.X.ToString() + "\n"
+ mainCore.Ball.Acceleration.Y.ToString() + "\n"
+ mainCore.Ball.Speed.X.ToString() + "\n"
+ mainCore.Ball.Speed.Y.ToString() + "\n"
+ sender.Size.Width + "\n"
+ sender.Size.Width
, 100, 100, Colors.Red);
}
private async void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (SharedMethods.isRunnnig)
{
ga.NewGenration();
UpdateUI();
count++;
SharedMethods.DrawPath(args.DrawingSession, SharedMethods.Locations, ga.BestGenes, Color.FromArgb(85, 255, 255, 255), 4f);
SharedMethods.DrawPath(args.DrawingSession, SharedMethods.Locations, ga.Population[elitism].Genes, Color.FromArgb(85, 255, 255, 255), 2f);
}
else
{
if (count > 0)
{
SharedMethods.DrawPath(args.DrawingSession, tourLocations, ga.BestGenes, Color.FromArgb(85, 255, 255, 255), 4f);
}
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
startBtn.Visibility = Visibility.Visible;
stopBtn.Visibility = Visibility.Collapsed;
});
sender.Paused = true;
}
}
private void prologControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
var textDisplay = GenerateTextDisplay(sender, (float)sender.Size.Width, (float)sender.Size.Height);
var blurEffect = new GaussianBlurEffect()
{
Source = textDisplay,
BlurAmount = 10
};
mTextOpacityBrush.StartPoint = mBlurOpacityBrush.StartPoint = new Vector2(0, 0);
mTextOpacityBrush.EndPoint = mBlurOpacityBrush.EndPoint = new Vector2(0, (float)sender.Size.Height);
var ds = args.DrawingSession;
//using (ds.CreateLayer(mBlurOpacityBrush))
//{
// ds.DrawImage(blurEffect);
//}
using (ds.CreateLayer(mTextOpacityBrush))
{
ds.DrawImage(textDisplay);
}
}
private void OnDraw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (_lineSpectrum != null && _audioProvider.IsPlaying)
{
_lineSpectrum.CreateSpectrumLine(sender, args.DrawingSession);
}
}
private void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (_inited)
{
var commandList = _drawForCanvas.GetCanvasImage(sender, 1, 1);
args.DrawingSession.DrawImage(commandList);
}
}
//CanvasAnimatedControl raises the Draw event on a periodic basis; by default it is called 60 times per second.
private void canvas_DrawAnimated(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
float radius = (float)(1 + Math.Sin(args.Timing.TotalTime.TotalSeconds)) * 10f;
blur.BlurAmount = radius;
args.DrawingSession.DrawImage(blur);
System.Diagnostics.Debug.WriteLine("Draw" + ">>>" + i++);
}
private void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (Machine.Painter.Canvas != null)
{
args.DrawingSession.Clear(Windows.UI.Colors.Transparent);
Machine.Painter.Draw(args.DrawingSession);
}
this.DrawingSession = args.DrawingSession;
}
public void Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
for (int ix = 0; ix < width; ix++)
{
for (int iy = 0; iy < height; iy++)
{
tiles[ix, iy].Draw(sender, args);
}
}
}
private async Task CreateResourcesAsync(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender)
{
ShipImage = await CanvasBitmap.LoadAsync(sender, "Assets/laserCharnesky.PNG");
AlienImage = await CanvasBitmap.LoadAsync(sender, "Assets/chalkboardGirlAlien.PNG");
LaserImage = await CanvasBitmap.LoadAsync(sender, "Assets/Redf.png");
Si = new SI(AlienImage, ShipImage, LaserImage);
}
private void Canvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
var opacityMask = CreateOpacityMask(sender, 800, 800);
var brush = new CanvasImageBrush(sender, opacityMask);
using (var layer = args.DrawingSession.CreateLayer(brush))
{
args.DrawingSession.FillRectangle(new Rect(100, 0, 500, 350), Colors.BlueViolet);
}
Canvas.Paused = true;
}
private void Canvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
var opacityMask = CreateOpacityMask(sender, 800, 800);
var bytes = opacityMask.GetPixelBytes();
var bmp = CanvasBitmap.CreateFromBytes(sender.Device, bytes, 800, 800, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized);
var brush = new CanvasImageBrush(sender, bmp);
using (var layer = args.DrawingSession.CreateLayer(brush))
{
args.DrawingSession.FillRectangle(new Rect(100, 0, 500, 350), Colors.BlueViolet);
}
Canvas.Paused = true;
}
private void Canvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
Si.DrawGame(args.DrawingSession);
/*//if (Window.Current.CoreWindow.GetKeyState(VirtualKey.Space).HasFlag(CoreVirtualKeyStates.Down))
* if (Window.Current.CoreWindow.GetAsyncKeyState(VirtualKey.Space) ==
* Windows.UI.Core.CoreVirtualKeyStates.Down)
* {
* Lasers laser = new Lasers(0, 0, LaserImage);
* laser.ShootLaser(LaserImage, Si.ship);
* laser.Image(args.DrawingSession);
* laser.Update(LaserImage);
* }*/
}
private void canvas_Update(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedUpdateEventArgs args)
{
_values.Add(_random.NextDouble());
double width = sender.Size.Width;
var lastPoints = _values.TakeLast(Convert.ToInt32(width / _barWidth));
lock (_points)
{
_points.Clear();
for (var i = 0; i < lastPoints.Count(); i++)
{
_points.Add(new Vector2(i, Convert.ToSingle(sender.Size.Height * lastPoints.ElementAt(i))));
}
}
}
private void canvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
lock (_points)
{
double height = sender.Size.Height;
foreach (var point in _points)
{
args.DrawingSession.DrawLine(
point.X * _barWidth,
Convert.ToSingle(height),
point.X * _barWidth,
Convert.ToSingle(height) - point.Y,
Colors.Green, 1);
}
}
}
private void DanmuCanvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
cl.Dispose();
cl = new CanvasCommandList(sender);
using (var clds = cl.CreateDrawingSession())
{
for (int i = 0; i < onDrawList.Count; i++)
{
clds.DrawText(onDrawList[i].Text, onDrawList[i].position.X + 2, onDrawList[i].position.Y + 1, Colors.Black);
clds.DrawText(onDrawList[i].Text, onDrawList[i].position, onDrawList[i].color);
}
}
args.DrawingSession.DrawImage(cl);
}
private void DrawWaveformCanvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
float xAxis = 0.0f;
for (int i = 0; i < waveformFloatData.Count; i++)
{
if (i == 0)
{
continue;
}
Vector2 point1 = new Vector2(xAxis, waveformFloatData[i - 1]);
Vector2 point2 = new Vector2(xAxis, waveformFloatData[i]);
args.DrawingSession.DrawLine(point1, point2, Colors.Red, 1f);
xAxis += 0.3f;
}
waveformFloatData.Clear();
}
private void canvas_Update(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedUpdateEventArgs args)
{
float elapsed = (float)args.Timing.ElapsedTime.TotalSeconds; // cast once, for speed.
scrollPos.X -= (elapsed * speed);
if ((useRenderTarget ? (scrollPos.X < -scrollerTarget.Bounds.Width) : (scrollPos.X < -scroller_layout.LayoutBounds.Width)))
{
scrollPos.X = tw;
}
#pragma warning disable CS4014 // we dont care about this
Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
chkSlow.IsChecked = args.Timing.IsRunningSlowly;
});
#pragma warning restore CS4014
UpdatefpsCounter.CountFPS();
}
private void NextLoopIdCanvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
var session = args.DrawingSession;
double time = mainPage.GetNowTimeMs();
float width = (float)sender.Size.Width;
float height = (float)sender.Size.Height;
session.DrawRectangle(0, 0, width, height, Colors.Black);
width /= 3;
if (tickms.Count > 1)
{
float nowtime = (float)mainPage.GetNowTimeMs();
//nowtime -= (loopms * 0.5);
nowtime -= (float)startms;
float pos = nowtime / (float)loopms;
int ii = (int)Math.Round(pos);
SetNextLoopId(ii);
pos = 1f - (pos - ii);
DrawSessionRectangle(session, width, height, pos - 2, ii - 2);
DrawSessionRectangle(session, width, height, pos - 1, ii - 1);
DrawSessionRectangle(session, width, height, pos, ii, true);
DrawSessionRectangle(session, width, height, pos + 1, ii + 1);
DrawSessionRectangle(session, width, height, pos + 2, ii + 2);
/*
* session.FillRectangle(pos * width, 0f, width, height, LoopBlockColors[ii % 5]);
* session.DrawText(ii.ToString(), pos * width, height / 3, Colors.Red);
*
* session.FillRectangle((pos - 1) * width, 0f, width, height, LoopBlockColors[(ii - 1 + 5) % 5]);
* session.DrawText((ii-1).ToString(), (pos - 1) * width, height / 3, Colors.Gray);
* session.FillRectangle((pos + 1) * width, 0f, width, height, LoopBlockColors[(ii + 1) % 5]);
* session.DrawText((ii + 1).ToString(), (pos + 1) * width, height / 3, Colors.Gray);
* session.FillRectangle((pos - 2) * width, 0f, width, height, LoopBlockColors[(ii - 2 + 5) % 5]);
* session.DrawText((ii - 2).ToString(), (pos - 2) * width, height / 3, Colors.Gray);
* session.FillRectangle((pos + 2) * width, 0f, width, height, LoopBlockColors[(ii + 2) % 5]);
* session.DrawText((ii + 2).ToString(), (pos + 2) * width, height / 3, Colors.Gray);
*/
}
session.DrawLine((float)sender.Size.Width / 2, 0, (float)sender.Size.Width / 2, height, Colors.Green);
}
private void canvas_Draw_1(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
double canvas_width = this.canvas.Size.Width;
double canvas_height = this.canvas.Size.Height;
// https://microsoft.github.io/Win2D/html/P_Microsoft_Graphics_Canvas_CanvasDrawingSession_Transform.htm
args.DrawingSession.Transform = Matrix3x2.CreateTranslation(new Vector2((float)(canvas_width / 2 - map.map_width / 2), (float)(canvas_height / 2 - map.map_height / 2)));
map.Draw(sender, args);
for (int index = 0; index < this.players.Length; index++)
{
this.players[index].Draw(sender, args, index);
}
//args.DrawingSession.DrawText("Hello, World!", 100, 100, Colors.Black);
//args.DrawingSession.DrawCircle(125, 125, 100, Colors.Green);
//args.DrawingSession.DrawLine(0, 0, 50, 200, Colors.Red);
}
private async void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (SharedMethods.isRunnnig)
{
var curDistance = SharedMethods.RoundTripDistance(tourLocations, tourOrder);
if (curDistance < bestTourDistance)
{
bestTourDistance = curDistance;
tourOrder.CopyTo(bestTourOrder, 0);
}
currentIteration++;
UpdateUI();
tourOrder = LexicographicOrder.Lexicography(tourOrder);
if (currentIteration >= totalIterations)
{
SharedMethods.isRunnnig = false;
}
else
{
SharedMethods.DrawPath(args.DrawingSession, tourLocations, tourOrder, Color.FromArgb(85, 255, 255, 255), 2f);
SharedMethods.DrawPath(args.DrawingSession, tourLocations, bestTourOrder, Color.FromArgb(85, 255, 255, 255), 4f);
}
}
else
{
if (currentIteration > 0)
{
SharedMethods.DrawPath(args.DrawingSession, tourLocations, bestTourOrder, Color.FromArgb(85, 255, 255, 255), 4f);
}
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
startBtn.Visibility = Visibility.Visible;
stopBtn.Visibility = Visibility.Collapsed;
});
sender.Paused = true;
}
}
public void Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender,
Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args, StateMachine.GameStateCodes gameState)
{
double screenWidth = sender.Size.Width;
double screenHeight = sender.Size.Height;
double hStride = System.Math.Floor(screenWidth / 6d);
double vStride = System.Math.Floor(screenHeight / 7d);
double hLeftover = screenWidth - (6d * hStride);
double vLeftover = screenHeight - (7d * vStride);
float hMargin = (float)System.Math.Floor(hLeftover / 2d);
float vMargin = (float)System.Math.Floor(vLeftover / 2d);
for (int i = 0; i < World.Globals.LocationCount; i++)
{
Arrangements.TileCoordinate coord = tileCoordinateHolder.TileCoordinateFor(i);
float x = hMargin + (float)(coord.Column * hStride);
float y = vMargin + (float)(coord.Row * vStride);
var r = new Windows.Foundation.Rect(x, y, (float)hStride, (float)vStride);
CanvasBitmap bitmap = bitmapHolder.BitmapForLocation(i);
args.DrawingSession.DrawImage(bitmap, r);
if (gameItemHolder.IsBerryAt(i) || gameState == StateMachine.GameStateCodes.StartingUp)
{
CanvasBitmap berryBitmap = bitmapHolder.BerryBitmap();
args.DrawingSession.DrawImage(berryBitmap, r);
}
if (gameItemHolder.IsBugAt(i) || gameState == StateMachine.GameStateCodes.StartingUp)
{
CanvasBitmap bugBitmap = bitmapHolder.BugBitmap();
args.DrawingSession.DrawImage(bugBitmap, r);
}
if (gameItemHolder.IsPlayerAt(i) || gameState == StateMachine.GameStateCodes.StartingUp)
{
if (blinkStateOn)
{
CanvasBitmap playerBitmap;
playerBitmap = bitmapHolder.PlayerIdleBitmap(picking);
args.DrawingSession.DrawImage(playerBitmap, r);
}
}
}
// draw message here
// fade it during the update function
}
private async void GamePadInput_Update(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedUpdateEventArgs args)
{
if (gamepad == null && Gamepad.Gamepads.Count > 0)
{
gamepad = Gamepad.Gamepads[0];
}
if (gamepad != null && ticks > DELAY_TICKS)
{
var reading = gamepad.GetCurrentReading();
switch (reading.Buttons)
{
case GamepadButtons.Menu:
case GamepadButtons.View:
case GamepadButtons.X:
case GamepadButtons.Y:
case GamepadButtons.A:
case GamepadButtons.B:
case GamepadButtons.DPadDown:
case GamepadButtons.DPadLeft:
case GamepadButtons.DPadRight:
case GamepadButtons.DPadUp:
case GamepadButtons.LeftShoulder:
case GamepadButtons.LeftThumbstick:
case GamepadButtons.Paddle1:
case GamepadButtons.Paddle2:
case GamepadButtons.Paddle3:
case GamepadButtons.Paddle4:
case GamepadButtons.RightShoulder:
case GamepadButtons.RightThumbstick:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() => { Frame.Navigate(typeof(GamePage)); });
break;
default:
break;
}
}
ticks++;
}
private void canvas_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
if (useRenderTarget)
{
args.DrawingSession.DrawImage(scrollerTarget, scrollPos);
}
else
{
args.DrawingSession.DrawTextLayout(scroller_layout, scrollPos, Colors.White);
}
if (showW2DFpsCounter)
{
DrawfpsCounter.Draw(args.DrawingSession);
}
if (showW2DUpdCounter)
{
UpdatefpsCounter.Draw(args.DrawingSession);
}
}
private void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args)
{
using (var cpb = new CanvasPathBuilder(args.DrawingSession))
{
cpb.BeginFigure(0, height);
average = averageSmoother.Smooth(AudioManager.AudioAverage);
Vector2 p0 = new Vector2(Point0, height - Adjust(smoother1.Smooth(AudioManager.AudioSpec1)) * height);
Vector2 p1 = new Vector2(Point1, height - Adjust(smoother2.Smooth(AudioManager.AudioSpec2)) * height);
Vector2 p2 = new Vector2(Point2, height - Adjust(smoother3.Smooth(AudioManager.AudioSpec3)) * height);
Vector2 p3 = new Vector2(Point3, height - Adjust(smoother4.Smooth(AudioManager.AudioSpec4)) * height);
Vector2 p4 = new Vector2(Point4, height - Adjust(smoother5.Smooth(AudioManager.AudioSpec5)) * height);
Vector2 p5 = new Vector2(Point5, height - Adjust(smoother6.Smooth(AudioManager.AudioSpec6)) * height);
Vector2 p6 = new Vector2(Point6, height - Adjust(smoother7.Smooth(AudioManager.AudioSpec7)) * height);
Vector2 p7 = new Vector2(Point7, height - Adjust(smoother8.Smooth(AudioManager.AudioSpec8)) * height);
Vector2 p8 = new Vector2(Point8, height - Adjust(smoother9.Smooth(AudioManager.AudioSpec9)) * height);
cpb.AddLine(p0);
cpb.AddCubicBezier(GetC1(p0), GetC2(p1), p1);
cpb.AddCubicBezier(GetC1(p1), GetC2(p2), p2);
cpb.AddCubicBezier(GetC1(p2), GetC2(p3), p3);
cpb.AddCubicBezier(GetC1(p3), GetC2(p4), p4);
cpb.AddCubicBezier(GetC1(p4), GetC2(p5), p5);
cpb.AddCubicBezier(GetC1(p5), GetC2(p6), p6);
cpb.AddCubicBezier(GetC1(p6), GetC2(p7), p7);
cpb.AddCubicBezier(GetC1(p7), GetC2(p8), p8);
cpb.AddLine(new Vector2(p8.X, height));
cpb.EndFigure(CanvasFigureLoop.Closed);
CanvasLinearGradientBrush gradient = new CanvasLinearGradientBrush(sender, TransparentBlurple, Blurple)
{
EndPoint = new Vector2(0, height + 48),
StartPoint = new Vector2(0, -12)
};
var path = CanvasGeometry.CreatePath(cpb);
//args.DrawingSession.DrawGeometry(path, Blurple, 1);
args.DrawingSession.FillGeometry(path, gradient);
}
}
