//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 }; }