//Loading (implicitly all) textures
public async Task CreateResourcesAsync(CanvasAnimatedControl sender, IncreaseLoadedPercentageDelegate increaseLoadedPercentage, OnCreateResourcesAsyncFinished onFinished)
{
//Set of all textureSets to be loaded
string[][] textureSets =
{
//Backgrounds
BG1, BG_CRATER_PLANET, BG_MESSIER,
BG_ROCKET_AND_PLANET, BG_STAR_CLUSTERS,
//Ships and their thrusts
SHIP1_BASE, SHIP1_THRUST,
SHIP2_BASE, SHIP2_THRUST,
SHIP3_BASE, SHIP3_THRUST,
SHIP4_BASE, SHIP4_THRUST,
SHIP5_BASE, SHIP5_THRUST,
SHIP6_BASE, SHIP6_THRUST,
SHIP7_BASE, SHIP7_THRUST,
SHIP8_BASE, SHIP8_THRUST,
SHIP9_BASE, SHIP9_THRUST,
SHIP10_BASE, SHIP10_THRUST,
SHIP11_BASE, SHIP11_THRUST,
SHIP12_BASE, SHIP12_THRUST,
//Bombs maybe?
DOOMDAY,
//Bullets
FIRE,
//Objects
HOT_SIDE_OBJECT
};
await CreateResourcesAsync(sender, increaseLoadedPercentage, onFinished, textureSets);
}
async Task CreateBitmapResourcesAsync(CanvasAnimatedControl sender)
{
_bitmap = await CanvasBitmap.LoadAsync(sender, "Assets/blank.png");
_bitmapCenter = _bitmap.Size.ToVector2() / 2;
_bitmapBounds = _bitmap.Bounds;
}
void CreateBrushes(CanvasAnimatedControl sender, CanvasBitmap bitmapTiger)
{
var bitmapSize = bitmapTiger.Size;
var scale = (radius * 2) / (float)bitmapSize.Height;
var backgroundEffect = new Transform2DEffect()
{
Source = bitmapTiger,
TransformMatrix = Matrix3x2.CreateScale(scale, scale) * Matrix3x2.CreateTranslation(center - radius, center - radius)
};
backgroundBrush = new CanvasImageBrush(sender, backgroundEffect)
{
SourceRectangle = new Rect(0, 0, size, size),
Opacity = 0.6f
};
hueRotationEffect = new HueRotationEffect()
{
Source = backgroundEffect,
Angle = (float)Math.PI * 0.5f
};
var foregroundEffect = new GaussianBlurEffect()
{
Source = hueRotationEffect,
BlurAmount = 10
};
foregroundBrush = new CanvasImageBrush(sender, foregroundEffect)
{
SourceRectangle = new Rect(0, 0, size, size)
};
}
public void RenderData(CanvasAnimatedControl canvas, CanvasAnimatedDrawEventArgs args, Color color, float thickness, List <XYZ> data)
{
using (var cpb = new CanvasPathBuilder(args.DrawingSession))
{
using (var dataSet2 = new CanvasPathBuilder(args.DrawingSession))
{
using (var dataSet3 = new CanvasPathBuilder(args.DrawingSession))
{
XYZ firstVal = data[0];
cpb.BeginFigure(new Vector2(0, (float)((firstVal.X + 32) * 10)));
dataSet2.BeginFigure(new Vector2(0, (float)((firstVal.Y + 32) * 10)));
dataSet3.BeginFigure(new Vector2(0, (float)((firstVal.Z + 32) * 10)));
int width = data.Count < Constants.ChartWidth ? data.Count : Constants.ChartWidth;
for (int i = 0; i < width; i++)
{
XYZ val = data[i];
cpb.AddLine(new Vector2(i, (float)(((val.X * -1) + 32) * 10)));
dataSet2.AddLine(new Vector2(i, (float)(((val.Y * -1) + 32) * 10)));
dataSet3.AddLine(new Vector2(i, (float)(((val.Z * -1) + 32) * 10)));
}
cpb.EndFigure(CanvasFigureLoop.Open);
dataSet2.EndFigure(CanvasFigureLoop.Open);
dataSet3.EndFigure(CanvasFigureLoop.Open);
args.DrawingSession.DrawGeometry(CanvasGeometry.CreatePath(cpb), Colors.Black, thickness);
args.DrawingSession.DrawGeometry(CanvasGeometry.CreatePath(dataSet2), Colors.Fuchsia, thickness);
args.DrawingSession.DrawGeometry(CanvasGeometry.CreatePath(dataSet3), Colors.PaleVioletRed, thickness);
}
}
}
}
public async Task CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
StartScreen = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/startscreen.png"));
FinishScreen = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/finishscreen.jpg"));
Food.CanvasBitmap = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/apple.png"));
HeadLeft = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_left.png"));
HeadUp = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_up.png"));
HeadRight = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_right.png"));
HeadDown = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_down.png"));
HeadEatLeft = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_eat_left.png"));
HeadEatUp = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_eat_up.png"));
HeadEatRight = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_eat_right.png"));
HeadEatDown = await ResourceManager.LoadBitmap(sender, new Uri("ms-appx:///Assets/Images/head_eat_down.png"));
StateManager.GoToNextState();
}
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
_c = Window.Current.Compositor;
_g = _c.CreateCompositionGenerator();
_rootShape = _c.CreateShapeVisual();
_rootShape.Size = new Vector2((float)RenderGrid.ActualWidth, (float)RenderGrid.ActualHeight);
_rootSize = _rootShape.Size.ToSize();
var rectGeom = _c.CreatePathGeometry(new CompositionPath(CanvasGeometry.CreateRectangle(_g.Device, new Rect(new Point(), _rootSize))));
var bgShape = _c.CreateSpriteShape(rectGeom);
bgShape.FillBrush = _c.CreateColorBrush(CanvasObject.CreateColor("#161616"));
_rootShape.Shapes.Add(bgShape);
for (var i = 0; i < MaxLayerCount; i++)
{
var shape = _c.CreateSpriteShape(_c.CreatePathGeometry(GetClip(_rootSize, 0f)));
// Offset each of the shape to the right to hide the bump of lower layers
shape.Offset = HideOffset;
shape.FillBrush = _c.CreateColorBrush(_colors[i]);
_rootShape.Shapes.Add(shape);
}
_selectedIndex = -1;
_swipeRightIndex = -1;
_swipeLeftIndex = MaxLayerCount;
_nextShapeIndex = -1;
// Reset offset of top most shape
_rootShape.Shapes[MaxLayerCount].Offset = Vector2.Zero;
ElementCompositionPreview.SetElementChildVisual(RenderGrid, _rootShape);
}
/// <summary>
/// Eroforrasok betoltese
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
async void Canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
//Setup
Sprite.Init(sender);
//Load spritesheets
assests_ready = await Sprite.LoadSheet(@"\resources\spritesheets\tiles_sheet_data.txt", @"\resources\spritesheets\tiles.png");
if (!Sprite.CreateSpriteFromColor("particle_normal", 100, 4, 4, 0xAA, 0xAA, 0xAA))
{
throw new Exception("Cannot create sprite from color");
}
if (!Sprite.CreateSpriteFromColor("particle_red", 101, 4, 4, 0xFF, 0x00, 0x00))
{
throw new Exception("Cannot create sprite from color");
}
//AnimatedSprite Setup
AnimatedSprite.Init(sender);
// Parallel osztályra keress rá
//Load AnimatedSpriteSheets
animated_assests_ready = await AnimatedSprite.LoadSheet(@"\resources\spritesheets\player_sheet_data.txt", @"\resources\spritesheets\player_sprites.png");
animated_assests_ready2 = await AnimatedSprite.LoadSheet(@"\resources\spritesheets\mobs_sheet_data.txt", @"\resources\spritesheets\mobs_sprites.png");
animated_assests_ready3 = await AnimatedSprite.LoadSheet(@"\resources\spritesheets\ui_sheet_data.txt", @"\resources\spritesheets\ui_sprites.png");
animated_assests_ready4 = await AnimatedSprite.LoadSheet(@"\resources\spritesheets\object_sheet_data.txt", @"\resources\spritesheets\object_sprites.png");
//LoadSounds
await Sound.LoadSound("test.mp3");
}
//Loads all resources asynchronously
async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
//Increases progress bar percentage
await TextureSetLoader.Instance.CreateResourcesAsync
(
sender
//Increases progress bar percentage during loading
, (increasePercentage) => { loadingProgressBar.Value += increasePercentage; }
//If not null, gets called back after loading gets finished
, null
//Loads all textures implicitly
);
//Music is also a resource
Log.i(this, "Loading music");
Music = await Utility.GetMusic(PageMusic);
//Music is implicitly started, but to be sure, we explicitly start it
//BUG: Music is not being looped
Music.Loaded += (a, b) => { Music.IsLooping = true; };
Music.IsLooping = true;
Music.Play();
Music.IsLooping = true;
Log.i(this, "Setting Field as loaded");
FieldLoaded = true;
Log.i(this, "CreateResourcesAsync finished");
}
void canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
Log.i(this, "CreateResources started");
//On losing device (the GPU one, not your cheap Windows Phone), resources gotta get reloaded
if (args.Reason == CanvasCreateResourcesReason.NewDevice)
{
Log.i(this, "Hey, a new device!");
//sender.Device.DeviceLost += Device_DeviceLost; //or maybe not
}
//If the reason is other, e.g. DPI change, we have to reload our textures too
TextureSetLoader.DeleteInstance();
//We create resources asynchronously
Task createResourcesAsync = CreateResourcesAsync(sender);
Log.i(this, "CreateResources starting parallel task for creating textures");
args.TrackAsyncAction(createResourcesAsync.AsAsyncAction());
//Failed attempt at syncing async
//args.GetTrackedAction().AsTask().GetAwaiter().GetResult();
//Log.i(this, "CreateResources parallel task has finished");
Log.i(this, "CreateResources finished");
}
async Task canvas_CreateResourcesAsync(CanvasAnimatedControl sender)
{
DissolveEffect = new PixelShaderEffect(await ReadAllBytes("Assets/Shaders/WipeUp.bin"));
//DissolveEffect.Properties["feather"] = 0.1f;
DissolveMask = await CreateRippleEffect();
CanvasSourceImageLarge1 = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///" + "Assets/Images/beautiful-bloom-blooming-blossom-414083.jpg"));
CanvasSourceImageLarge2 = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///" + "Assets/Images/nature-red-forest-leaves-33109.jpg"));
CanvasSourceImageSmall1 = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///" + "Assets/Images/beach-birds-calm-clouds-219998.jpg"));
CanvasSourceImageSmall2 = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///" + "Assets/Images/photography-of-trees-covered-with-snow-773594.jpg"));
try
{
var info = Windows.Graphics.Display.DisplayInformation.GetForCurrentView();
DissolveEffect.Properties["dpi"] = info.LogicalDpi;
DissolveEffect.Properties["height"] = 369f;
//DissolveEffect.Properties["progress"] = (float)ProgressSlider.Value;
DissolveEffect.Source1 = CanvasSourceImageSmall1;
//DissolveEffect.Source2 = CanvasSourceImageSmall2;
}
catch { }
}
private async Task ReflashBackground(CanvasAnimatedControl resource, string imgPath)
{
if (imgPath == null)
{
return;
}
if (imgbackground == null || oldImgPath != imgPath)
{
oldImgPath = imgPath;
imgbackground = await CanvasBitmap.LoadAsync(resource, new Uri(imgPath), 96);
}
if (blurEffect == null)
{
blurEffect = new GaussianBlurEffect()
{
BlurAmount = 40.0f,
BorderMode = EffectBorderMode.Soft,
Optimization = EffectOptimization.Speed
};
}
blurEffect.Source = imgbackground;
if (scaleEffect == null)
{
scaleEffect = new ScaleEffect()
{
CenterPoint = new System.Numerics.Vector2()
};
}
scaleEffect.Source = blurEffect;
scaleEffect.Scale = new System.Numerics.Vector2(await ComputeScaleFactor());
resource.Paused = false;
}
//Loads all resources asynchronously
async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
//Loads textures asynchronously
await TextureSetLoader.Instance.CreateResourcesAsync
(
sender
//Increases progress bar percentage during loading
, (increasePercentage) => { loadingProgressBar.Value += increasePercentage; }
//If not null, gets called back after loading gets finished
, null
//Only loads the required backgrounds for faster loading time
, MainMenuBackground.backgrounds
);
//Music is also a resource
Log.i(this, "Loading music");
Music = await Utility.GetMusic(PageMusic);
//Music is implicitly started, but to be sure, we explicitly start it
//BUG: Music is not being looped
LoadVolume();
Music.Play();
Music.IsLooping = true;
Log.i(this, "Setting Field as loaded");
FieldLoaded = true;
Log.i(this, "CreateResourcesAsync finished");
}
public async Task Initialize(CanvasAnimatedControl canvasAnimatedControl, T scene)
{
if (canvasAnimatedControl == null)
{
throw new ArgumentNullException(nameof(canvasAnimatedControl));
}
if (scene == null)
{
throw new ArgumentNullException(nameof(scene));
}
_canvasAnimatedControl = canvasAnimatedControl;
Scene = scene;
await _canvasAnimatedControl.RunOnGameLoopThreadAsync(() =>
{
_inputSource = canvasAnimatedControl.CreateCoreIndependentInputSource(CoreInputDeviceTypes.Mouse |
CoreInputDeviceTypes.Pen |
CoreInputDeviceTypes.Touch);
_inputSource.PointerPressed += OnPointerPressed;
_inputSource.PointerMoved += OnPointerMoved;
_inputSource.PointerReleased += OnPointerReleased;
});
DoInitialize();
}
public static CanvasBitmap RenderFromShape(CanvasAnimatedControl canvas, float width, float height, Shape shape, float thickness = 2, bool filled = false)
{
var renderTarget = new CanvasRenderTarget(canvas, width * SCALE_FACTOR, height * SCALE_FACTOR);
var pathBuilder = new CanvasPathBuilder(canvas.Device);
pathBuilder.BeginFigure(shape.Points.First() * SCALE_FACTOR);
foreach (Vector2 point in shape.Points.Skip(1))
{
pathBuilder.AddLine(point * SCALE_FACTOR);
}
pathBuilder.EndFigure(shape.Closed ? CanvasFigureLoop.Closed : CanvasFigureLoop.Open);
using (var ds = renderTarget.CreateDrawingSession())
{
if (filled)
{
ds.FillGeometry(CanvasGeometry.CreatePath(pathBuilder), Colors.White);
}
else
{
ds.DrawGeometry(CanvasGeometry.CreatePath(pathBuilder), Colors.White, thickness * SCALE_FACTOR);
}
}
return(renderTarget);
}
async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
// c.TargetElapsedTime = new TimeSpan(0, 0, 0, 0, 200);
// c.Paused = true;
Statics.CrownImage = await CanvasBitmap.LoadAsync(sender, "game\\crown.png");
Statics.LeftColumnWidth = (int)sender.Size.Width - Statics.RightColumnWidth - Statics.RightColumnPadding * 2 - Statics.LeftColumnPadding * 2;
Statics.CanvasHeight = (int)sender.Size.Height;
Statics.ColumnDividerTop = new Vector2(Statics.LeftColumnWidth + Statics.LeftColumnPadding * 2, 0);
Statics.ColumnDividerBottom = new Vector2(Statics.LeftColumnWidth + Statics.LeftColumnPadding * 2, (float)sender.Size.Height);
rlbProminent = new RichListBoxProminent(sender.Device,
new Vector2(Statics.LeftColumnWidth + Statics.LeftColumnPadding * 2 + Statics.RightColumnPadding, Statics.RightColumnPadding),
Statics.RightColumnWidth,
"Census of Recent Contentions", Statics.FontLarge,
15, Statics.FontSmall,
Statics.FontLarge);
rlbLeaderboard = new RichListBoxLeaderboard(sender.Device,
new Vector2(rlbProminent.Position.X, rlbProminent.Position.Y + rlbProminent.Height + Statics.RightColumnPadding),
rlbProminent.Width,
(int)sender.Size.Height - rlbProminent.Height - Statics.RightColumnPadding * 3,
"Champions of the Realm",
Statics.FontLarge,
Statics.FontSmall,
Statics.FontMedium);
// initialize leaderboard listbox
Leaderboard.AttachedListbox = rlbLeaderboard;
Leaderboard.InitializeListboxInfo();
// resets map, listbox, debug frame count
Reset(sender);
}
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
{
return;
}
if (args.Reason == CanvasCreateResourcesReason.FirstTime)
{
bool spriteBatchSupported = false;
#if WINDOWS_UWP
spriteBatchSupported = CanvasSpriteBatch.IsSupported(sender.Device);
#endif
UseSpriteBatch = spriteBatchSupported;
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("UseSpriteBatch"));
}
UseSpriteBatchCheckBox.Visibility = spriteBatchSupported ? Visibility.Visible : Visibility.Collapsed;
}
args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction());
}
private void RenderPanelUnloaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
RenderPanel.Update -= RenderPanelUpdate;
RenderPanel.Draw -= RenderPanelDraw;
RenderPanel.Unloaded -= RenderPanelUnloaded;
RenderPanel = null;
}
private void AnimatedControl_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
// Initialize the brushes.
backgroundDefaultBrush = CreateRadialGradientBrush(sender,
Color.FromArgb(0x00, 0x6E, 0xEF, 0xF8), Color.FromArgb(0x4D, 0x6E, 0xEF, 0xF8));
backgroundAnswerCorrectBrush = CreateRadialGradientBrush(sender,
Color.FromArgb(0x00, 0x42, 0xC9, 0xC5), Color.FromArgb(0x4D, 0x42, 0xC9, 0xC5));
backgroundAnswerIncorrectBrush = CreateRadialGradientBrush(sender,
Color.FromArgb(0x00, 0xDE, 0x01, 0x99), Color.FromArgb(0x4D, 0xDE, 0x01, 0x99));
borderDefaultBrush = new CanvasSolidColorBrush(sender, Color.FromArgb(0xFF, 0x6E, 0xEF, 0xF8));
borderGradientBrush = new CanvasLinearGradientBrush(sender,
Color.FromArgb(0xFF, 0x0F, 0x56, 0xA4), Color.FromArgb(0xFF, 0x6E, 0xEF, 0xF8))
{
StartPoint = new Vector2(centerPoint.X - radius, centerPoint.Y),
EndPoint = new Vector2(centerPoint.X + radius, centerPoint.Y)
};
borderAnswerCorrectBrush = new CanvasSolidColorBrush(sender, Color.FromArgb(0xFF, 0x42, 0xC9, 0xC5));
borderAnswerIncorrectBrush = new CanvasSolidColorBrush(sender, Color.FromArgb(0xFF, 0xDE, 0x01, 0x99));
// Calculate the text position for vertical centering to account for the
// fact that text is not vertically centered within its layout bounds.
var textLayout = new CanvasTextLayout(sender, "0123456789", textFormat, 0, 0);
var drawMidpoint = (float)(textLayout.DrawBounds.Top + (textLayout.DrawBounds.Height / 2));
var layoutMidpoint = (float)(textLayout.LayoutBounds.Top + (textLayout.LayoutBounds.Height / 2));
var textPositionDelta = drawMidpoint - layoutMidpoint;
textPosition = new Vector2(centerPoint.X, centerPoint.Y - textPositionDelta);
}
private void UpdateWin2DCanvas()
{
if (unloaded)
{
return;
}
if (ItemsPanelRoot is GooeyButtonItemsPanel panel)
{
if (this.panel == null)
{
this.panel = panel;
}
if (Win2DCanvas == null)
{
Win2DCanvas = new CanvasAnimatedControl();
Win2DHost.Children.Add(Win2DCanvas);
Win2DCanvas.IsHitTestVisible = false;
Win2DCanvas.CreateResources += OnWin2DCreateResources;
Win2DCanvas.Draw += OnWin2DDraw;
}
var radius = panel.Children.Count == 0 ? 0 : panel.Children.Max(c => c.RenderSize.IsEmpty ? 0 : Math.Max(c.RenderSize.Width, c.RenderSize.Height));
var size = (Distance + radius * 4) * 2;
Win2DCanvas.Width = size;
Win2DCanvas.Height = size;
property.CenterPoint = new Vector2((float)size / 2);
Canvas.SetLeft(Win2DCanvas, -size / 2);
Canvas.SetTop(Win2DCanvas, -size / 2);
}
}
private async Task Canvas_CreateResourcesAsync(CanvasAnimatedControl sender)
{
sweepRenderer = await SweepRenderer.Create(sender);
updatesPerDrawRenderer = new UpdatesPerDrawRenderer();
touchPointsRenderer = new TouchPointsRenderer(sender);
}
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
return;
args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction());
}
/// <summary>
/// Handles the reading of image files from a json FileList
/// </summary>
/// <param name="sender">the canvas that the images are loaded to</param>
/// <param name="assetLocation">The name of the folder within the assets folder</param>
/// <returns>A dictionary containing the images with a nameID</returns>
public static async Task <Dictionary <string, CanvasBitmap> > LoadImages(CanvasAnimatedControl sender, string assetLocation)
{
Dictionary <string, CanvasBitmap> result = new Dictionary <string, CanvasBitmap>();
try
{
StorageFolder storageFolder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync($"Assets\\{assetLocation}");
FileList fileList = await ParseLoadAssetsJson(storageFolder);
// if the file doesn't state the correct FileType don't try to load any files
if (fileList.FileType != "CanvasBitmap")
{
return(null);
}
foreach (File file in fileList.Files)
{
result.Add(file.NameID, await CanvasBitmap.LoadAsync(sender, new Uri($"ms-appx:///Assets/{assetLocation}/{file.FileName}")));
}
}
catch (Exception)
{
throw;
}
return(result);
}
async Task createResourcesAsync(CanvasAnimatedControl sender)
{
_spriteSheet = await CanvasBitmap.LoadAsync(resourceCreator : sender, fileName : "assets/dirt-tiles.png");
//string jsonString = await DeserializeFileAsync("./Assets/tilemap.json");
_tiledDrawerStronlytyped = await TiledParser_loose.Create(_spriteSheet, @"Assets\tilemap.json");
}
protected override void OnApplyTemplate()
{
_animatedControl = GetTemplateChild("AnimatedControl") as CanvasAnimatedControl;
_animatedControl.Update += AnimatedControl_Update;
_animatedControl.Draw += AnimatedControl_Draw;
base.OnApplyTemplate();
}
private async void OnCreateResource(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
//var device = sender.Device;
var device = CanvasDevice.GetSharedDevice();
localBitmap = await CanvasBitmap.LoadAsync(device, new Uri("ms-appx:///Assets/casa.jpg"));
}
public void Resize(CanvasAnimatedControl canvas, Size size)
{
renderSize = size;
if (canvasIsLoaded)
{
RecreateRenderTarget(canvas);
}
}
private void canvasMain_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
Statics.Initialize(sender.Device);
UI.Initialize(sender);
Game.Initialize();
Game.OnGameCommand += Game_OnGameCommand;
}
private void Canvas_CreateResources(CanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.CanvasCreateResourcesEventArgs args)
{
for (int i = 0; i < 6; i++)
{
Items.Add(new Uri($"ms-appx:///Assets/Images/loadinganim{i}.png"));
}
args.TrackAsyncAction(Canvas_CreateResourcesAsync(sender).AsAsyncAction());
}
/// <summary>
/// Loads the image resources and game manager into memory asynchronously.
/// </summary>
private async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
background = await CanvasBitmap.LoadAsync(sender, "Images/Background.png");
spriteSheet = await CanvasBitmap.LoadAsync(sender, "Images/Sprites.png");
gameManager = new GameManager(background, spriteSheet);
}
private void canvasMain_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
Statics.Initialize(sender.Device);
UI.Initialize(sender);
Game.Initialize();
Game.OnGameCommand += Game_OnGameCommand;
}
public void CreateResources(ref CanvasAnimatedControl sender, ref List<Img> imgQueue)
{
foreach (var img in imgQueue)
{
AddImg(img);
}
imgQueue.Clear();
}
public ParticlesManager(CanvasAnimatedControl canvas, int amount = 10)
{
parent = canvas;
device = canvas.Device;
bounds = new Size(canvas.ActualWidth, canvas.ActualHeight);
clearColor = (canvas.Background as SolidColorBrush).Color;
amountparticles = amount;
}
public void CreateResources(ref CanvasAnimatedControl sender, ref List <Img> imgQueue)
{
foreach (var img in imgQueue)
{
AddImg(img);
}
imgQueue.Clear();
}
async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
await smokePlume.CreateResourcesAsync(sender);
await smoke.CreateResourcesAsync(sender);
await explosion.CreateResourcesAsync(sender);
}
private void RenderPanelUnloaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
RenderPanel.CreateResources -= RenderPanelCreateResources;
RenderPanel.Update -= RenderPanelUpdate;
RenderPanel.Draw -= RenderTargetManager.CanvasDraw;
RenderPanel.Unloaded -= RenderPanelUnloaded;
RenderPanel = null;
}
public void Initialize(ref CanvasAnimatedControl cac)
{
canvas = cac;
canvas.CreateResources += Canvas_CreateResources;
canvas.Draw += Canvas_Draw;
canvas.TargetElapsedTime = TimeSpan.FromMilliseconds(30);
Window.Current.SizeChanged += Current_SizeChanged;
slideshow = new ImgClassicSlideshow();
}
async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
Statics.CanvasDevice = sender.Device;
Statics.CanvasWidth = sender.Size.Width;
Statics.CanvasHeight = sender.Size.Height;
CalculateLayout();
// initialize feeds
await FeedDataSource.LoadFeedItemsAsync();
}
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
return;
bool spriteBatchSupported = false;
#if WINDOWS_UWP
spriteBatchSupported = CanvasSpriteBatch.IsSupported(sender.Device);
#endif
UseSpriteBatch = UseSpriteBatchCheckBox.IsChecked.GetValueOrDefault(false);
UseSpriteBatchCheckBox.Visibility = spriteBatchSupported ? Visibility.Visible : Visibility.Collapsed;
args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction());
}
private void CanvasAnimatedControl_OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
// blobs
_blobs = new List<Blob>();
var rnd = new Random();
for (int i = 0; i < BlobCount; i++)
{
_blobs.Add(new Blob
{
Position = new Vector2((float) (rnd.NextDouble()*sender.Size.Width), (float) (rnd.NextDouble()*sender.Size.Height)),
Velocity = new Vector2(BlobVelocityScale * (float) ((rnd.NextDouble()*3.0f) - 1.5f), BlobVelocityScale * (float) ((rnd.NextDouble()*3.0f) - 1.5f))
});
}
// texture
var rgb = new CanvasRadialGradientBrush(sender, new[]
{
new CanvasGradientStop
{
Color = Color.FromArgb(255, 128, 128, 255),
Position = 0.0f
},
new CanvasGradientStop
{
Color = Color.FromArgb(128, 128, 128, 255),
Position = 0.6f
},
new CanvasGradientStop
{
Color = Color.FromArgb(0, 128, 128, 255),
Position = 1.0f
}
});
rgb.RadiusX = rgb.RadiusY = BlobSize;
_blobBrush = rgb;
// table transfer table
ttt = new List<float>();
for (int i = 0; i < 100; i++)
{
ttt.Add(i < Threshold ? 0.0f : 1.0f);
}
// setup
_blobRenderTarget = new CanvasRenderTarget(sender, sender.Size);
_pre = new PremultiplyEffect {Source = _blobRenderTarget};
_tte = new TableTransferEffect {ClampOutput = true, Source = _pre};
_tte.AlphaTable = _tte.RedTable = _tte.GreenTable = _tte.BlueTable = ttt.ToArray();
_un = new UnPremultiplyEffect {Source = _tte};
_gbe = new GaussianBlurEffect {BlurAmount = 8.0f, Source = _un};
_mask = new CanvasImageBrush(sender) {SourceRectangle = new Rect(new Point(), sender.Size)};
}
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
// Create a gradient brush, used to control layer opacity.
var gradientStops = new CanvasGradientStop[]
{
new CanvasGradientStop { Position = 0, Color = Colors.White },
new CanvasGradientStop { Position = 0.25f, Color = Colors.White },
new CanvasGradientStop { Position = 1, Color = Colors.Transparent },
};
gradientBrush = new CanvasRadialGradientBrush(sender, gradientStops);
// Create a star shaped geometry, used for layer clipping.
clipGeometry = Utils.CreateStarGeometry(sender, 1, Vector2.Zero);
}
public CanvasStage( CanvasAnimatedControl Stage )
{
_stage = Stage;
Scenes = new List<IScene>();
Textures = new TextureLoader();
Stage.CreateResources += Stage_CreateResources;
Stage.GameLoopStarting += Stage_GameLoopStarting;
Stage.GameLoopStopped += Stage_GameLoopStopped;
Stage.SizeChanged += Stage_SizeChanged;
Stage.Unloaded += Stage_Unloaded;
}
private void CanvasAnimatedControl_OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
_particles = new List<WaveParticle>();
var modX = (float)((sender.Size.Width/ParticleCount)/2.0);
for (int i = 0; i < ParticleCount; i++)
{
_particles.Add(new WaveParticle
{
Velocity = 0.0f,
Position = new Vector2((float)((sender.Size.Width / ParticleCount) * i) + modX, WaveParticle.HeightLevel),
DrawPosition = new Vector2((float)((sender.Size.Width / ParticleCount) * i) + modX, 0.0f),
DrawVelocity = new Vector2((float)((sender.Size.Width / ParticleCount) * i) + modX, 0.0f),
RenderHeight = sender.Size.Height
});
}
}
async Task Canvas_CreateResourcesAsync(CanvasAnimatedControl sender)
{
bitmapTiger = await CanvasBitmap.LoadAsync(sender, "imageTiger.jpg");
bitmapSize = bitmapTiger.Size.ToVector2();
// The Dissolve shader has two input textures:
//
// - The first is an image that will be dissolved away to nothing.
//
// - The second is a dissolve mask whose red channel controls the order in which pixels
// of the first image disappear as the dissolveAmount property is animated.
//
// This example selects different dissolve masks depending on the CurrentEffect.
dissolveEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Dissolve.bin"))
{
Source1 = bitmapTiger
};
// The Ripples shader has no input textures.
// It generates an animatable series of concentric circles.
// This is used as a mask input to the dissolveEffect.
rippleEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Ripples.bin"));
rippleEffect.Properties["frequency"] = 0.15f;
rippleEffect.Properties["dpi"] = sender.Dpi;
#if WINDOWS_UWP
rippleEffect.Properties["center"] = bitmapSize / 3;
#else
rippleEffect.Properties["center"] = (Microsoft.Graphics.Canvas.Numerics.Vector2)(bitmapSize / 3);
// When compiling for Windows 8.1, we must explicitly convert vector and matrix values
// from System.Numerics to their Microsoft.Graphics.Canvas.Numerics equivalents before
// passing them to PixelShaderEffect.Properties. This is not neccessary when targetting
// UWP, which handles the conversion automatically. For more info, see the article:
// http://blogs.msdn.com/b/win2d/archive/2015/06/02/winrt-vector-and-matrix-types-in-windows-10.aspx
#endif
// Create other dissolve mask images.
CreateTurbulence();
CreateLinearGradient(sender);
CreateRadialGradient(sender);
}
void canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
// Create the Direct3D teapot model.
teapot = new TeapotRenderer(sender);
// Create Win2D resources for drawing the scrolling text.
var textFormat = new CanvasTextFormat
{
FontSize = fontSize,
HorizontalAlignment = CanvasHorizontalAlignment.Center
};
textLayout = new CanvasTextLayout(sender, scrollingText, textFormat, textRenderTargetSize - textMargin * 2, float.MaxValue);
textRenderTarget = new CanvasRenderTarget(sender, textRenderTargetSize, textRenderTargetSize);
// Set the scrolling text rendertarget (a Win2D object) as
// source texture for our 3D teapot model (which uses Direct3D).
teapot.SetTexture(textRenderTarget);
}
private void Resize(CanvasAnimatedControl sender)
{
sender.Paused = true;
var size = (float)Math.Min(sender.Size.Width, sender.Size.Height);
if (sender.Size.Width > sender.Size.Height)
{
_xCorrection = ((float)sender.Size.Width - size) / 2.0f;
}
else
{
_yCorrection = ((float)sender.Size.Height - size) / 2.0f;
}
var moveBy = size / 10.0f;
var pad = moveBy / 2.0f;
lock (_staticPoints)
{
_staticPoints.Clear();
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
_staticPoints.Add(new GridPoint
{
IsInteractive = i > 1 && i < 8 && j > 1 && j < 8,
Position = new Vector2(_xCorrection + pad + i * moveBy, _yCorrection + pad + j * moveBy)
});
}
}
}
lock (_movingPoints)
{
_movingPoints.Clear();
//var bp = new BezierPath(new Vector2(_xCorrection + pad + 2 * moveBy, _yCorrection + pad + 2 * moveBy));
//bp.AddCurve(new Vector2(_xCorrection + pad + 2 * moveBy, _yCorrection + pad + 2 * moveBy));
var mp = new MovingGridPoint();
_movingPoints.Add(mp);
}
sender.Paused = false;
}
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
return;
if (args.Reason == CanvasCreateResourcesReason.FirstTime)
{
bool spriteBatchSupported = false;
#if WINDOWS_UWP
spriteBatchSupported = CanvasSpriteBatch.IsSupported(sender.Device);
#endif
UseSpriteBatch = spriteBatchSupported;
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs("UseSpriteBatch"));
UseSpriteBatchCheckBox.Visibility = spriteBatchSupported ? Visibility.Visible : Visibility.Collapsed;
}
args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction());
}
public static void Initialize(CanvasAnimatedControl sender)
{
Canvas = sender;
Vector2 textboxPosition = new Vector2(20, (float)sender.Size.Height - 50);
textbox = new win2d_Textbox(sender.Device, textboxPosition, 600);
button = new win2d_Button(sender.Device, new Vector2(textboxPosition.X + textbox.Width + 20, textboxPosition.Y), 100, textbox.Height, "Test button!");
button.Click += Button_Click;
textblock = new win2d_Textblock(new Vector2(20, 20), textbox.Width + 20 + button.Width, (int)sender.Size.Height - textbox.Height - 40, true);
// START DEBUG
for (int i = 100; i < 200; i++)
{
StringBuilder s = new StringBuilder();
s.Append(i.ToString());
for (int j = 0; j < 29; j++)
{
s.Append(" ");
s.Append(i.ToString());
}
textblock.Append(sender.Device, s.ToString());
}
// END DEBUG
scrollbar = new win2d_ScrollBar(new Vector2(textblock.Position.X + textblock.Width, textblock.Position.Y), 20, textblock.Height);
scrollbar.ScrollUp += Scrollbar_ScrollUp;
scrollbar.ScrollDown += Scrollbar_ScrollDown;
scrollbar.ScrollToTop += Scrollbar_ScrollToTop;
scrollbar.ScrollToBottom += Scrollbar_ScrollToBottom;
Controls.Add(textbox);
Controls.Add(button);
Controls.Add(textblock);
Controls.Add(scrollbar);
}
async Task Canvas_CreateResourcesAsync(CanvasAnimatedControl sender)
{
bitmapTiger = await CanvasBitmap.LoadAsync(sender, "imageTiger.jpg");
tigerSize = bitmapTiger.Size.ToVector2();
// The Sketch shader has two input textures:
//
// - First is the image that will be processed by the sketch effect.
// The sketch shader applies a 3x3 edge detection filter kernel to this input,
// so we specify Offset coordinate mapping mode with a max offset of 1 dip.
//
// - Second is an overlay containing a pencil sketch texture. The JitterX and JitterY
// properties offset this by randomly varying amounts, so we specify Unknown mapping
// mode to indicate that the entire image must be made available to the shader.
sketchEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Sketch.bin"))
{
Source1 = bitmapTiger,
Source1BorderMode = EffectBorderMode.Hard,
Source1Mapping = SamplerCoordinateMapping.Offset,
MaxSamplerOffset = (int)Math.Ceiling(sender.Dpi / 96),
Source2 = await CanvasBitmap.LoadAsync(sender, "Shaders/SketchTexture.jpg"),
Source2Mapping = SamplerCoordinateMapping.Unknown
};
sketchEffect.Properties["EdgeOffset"] = sender.Dpi / 96;
// The Dissolve shader has two input textures:
//
// - The first is an image that will be dissolved away to nothing.
//
// - The second is a dissolve mask whose red channel controls the order in which pixels
// of the first image disappear as the dissolveAmount property is animated.
//
// This example selects different dissolve masks depending on the CurrentEffect.
dissolveEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Dissolve.bin"));
// The Ripples shader has no input textures.
// It generates an animatable series of concentric circles.
// This is used as a mask input to the dissolveEffect.
rippleEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Ripples.bin"));
rippleEffect.Properties["frequency"] = 0.15f;
rippleEffect.Properties["dpi"] = sender.Dpi;
#if WINDOWS_UWP
rippleEffect.Properties["center"] = tigerSize / 3;
#else
rippleEffect.Properties["center"] = (Microsoft.Graphics.Canvas.Numerics.Vector2)(tigerSize / 3);
// When compiling for Windows 8.1, we must explicitly convert vector and matrix values
// from System.Numerics to their Microsoft.Graphics.Canvas.Numerics equivalents before
// passing them to PixelShaderEffect.Properties. This is not neccessary when targetting
// UWP, which handles the conversion automatically. For more info, see the article:
// http://blogs.msdn.com/b/win2d/archive/2015/06/02/winrt-vector-and-matrix-types-in-windows-10.aspx
#endif
// Create other dissolve mask images.
CreateTurbulence();
CreateLinearGradient(sender);
CreateRadialGradient(sender);
}
async Task CreateResourcesAsync(CanvasAnimatedControl sender)
{
await smokePlume.CreateResourcesAsync(sender);
await smoke.CreateResourcesAsync(sender);
await explosion.CreateResourcesAsync(sender);
}
private async Task PerformBasicTouchNavigation(CanvasAnimatedControl canvas, Vector2 position)
{
var x = position.X / canvas.Size.Width * 2 - 1;
var y = position.Y / canvas.Size.Height * 2 - 1;
Point direction;
if (Math.Abs(x) < Math.Abs(y))
direction = y < 0 ? Point.North : Point.South;
else
direction = x < 0 ? Point.West : Point.East;
await GameClient.MovePlayerAsync(direction);
}
virtual protected async Task LoadTextures( CanvasAnimatedControl CC )
{
await Textures.Load( CC, Texture.Glitter, "Assets/glitter.dds" );
await Textures.Load( CC, Texture.Circle, "Assets/circle.dds" );
}
public CanvasStage( CanvasAnimatedControl Stage, TextureLoader SharedTextures )
: this( Stage )
{
Stage.CreateResources -= Stage_CreateResources;
Textures = SharedTextures;
}
private void Canvas_CreateResources(
CanvasAnimatedControl sender,
CanvasCreateResourcesEventArgs args)
{
this.initialized = true;
}
void canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
_canvas = (CanvasAnimatedControl)GetTemplateChild("canvas");
_canvas.CreateResources += Canvas_CreateResources;
_canvas.Draw += Canvas_Draw;
}
private async void Canvas_CreateResources(CanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.CanvasCreateResourcesEventArgs args)
{
AddImg("ms-appx:///Assets/wallpaper.jpg");
}
private void AeroPanel_Unloaded(object sender, RoutedEventArgs e)
{
DisplayInformation.GetForCurrentView().DpiChanged -= DpiChanged;
if (_canvas != null)
{
_canvas.RemoveFromVisualTree();
_canvas = null;
}
}
virtual protected void Stage_CreateResources( CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args )
{
args.TrackAsyncAction( LoadTextures( sender ).AsAsyncAction() );
}
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
var stops = new CanvasGradientStop[]
{
new CanvasGradientStop() { Color=Colors.Transparent, Position=0.1f },
new CanvasGradientStop() { Color=Colors.White, Position = 0.3f },
new CanvasGradientStop() { Color=Colors.White, Position = 0.7f },
new CanvasGradientStop() { Color=Colors.Transparent, Position = 0.9f },
};
textOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied);
stops = new CanvasGradientStop[]
{
new CanvasGradientStop() { Color=Colors.White, Position=0.0f },
new CanvasGradientStop() { Color=Colors.Transparent, Position = 0.3f },
new CanvasGradientStop() { Color=Colors.Transparent, Position = 0.7f },
new CanvasGradientStop() { Color=Colors.White, Position = 1.0f },
};
blurOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied);
}
private void Canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
_effect = new GaussianBlurEffect()
{
BlurAmount = 5,
BorderMode = EffectBorderMode.Hard
};
}
