void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { if (args.Reason == CanvasCreateResourcesReason.DpiChanged) return; args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction()); }
private void canvasMain_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { Statics.Initialize(sender.Device); UI.Initialize(sender); Game.Initialize(); Game.OnGameCommand += Game_OnGameCommand; }
void Canvas_CreateResources(CanvasVirtualControl sender, CanvasCreateResourcesEventArgs args) { // Don't bother reloading our shaders if it is only the DPI that changed. // That happens all the time due to ScrollViewer_ViewChanged adjusting canvas.DpiScale. if (args.Reason == CanvasCreateResourcesReason.DpiChanged) return; args.TrackAsyncAction(Canvas_CreateResourcesAsync(sender).AsAsyncAction()); }
private void BackgroundCanvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Task.Run(async () => { // Load the background image and create an image brush from it this.backgroundImage = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///Background.jpg")); this.backgroundBrush = new CanvasImageBrush(sender, this.backgroundImage); // Set the brush's edge behaviour to wrap, so the image repeats if the drawn region is too big this.backgroundBrush.ExtendX = this.backgroundBrush.ExtendY = CanvasEdgeBehavior.Wrap; this.resourcesLoaded = true; }).AsAsyncAction()); }
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()); }
void Canvas_CreateResources(ICanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { if (args.Reason == CanvasCreateResourcesReason.DpiChanged) { // These resources are all DPI independent, so no need to recreate them // if only the DPI has changed. return; } CreateFlameEffect(); text = null; newText = textInput.Text; }
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)}; }
public async Task CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { var tasks = Game.Contents .Where(x => !(x is SpriteFont)) .Select(x => (x, CanvasBitmap.LoadAsync(sender.Device, new Uri($@"ms-appx:///GameContent/{x.Path}.png")).AsTask())) .ToArray(); await Task.WhenAll(tasks.Select(x => x.Item2)).ConfigureAwait(false); foreach (var task in tasks) { _bitmapDictionary[task.Item1.Path] = task.Item2.Result; } }
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); }
void Canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(LoadCanvasResources(sender).AsAsyncAction()); imageBrush = new CanvasImageBrush(sender); imageSource = new CanvasImageSource(sender, controlSize, controlSize); imageControl.Source = imageSource; virtualImageSource = new CanvasVirtualImageSource(sender, controlSize, controlSize); virtualImageControl.Source = virtualImageSource.Source; swapChain = new CanvasSwapChain(sender, controlSize, controlSize); swapChainPanel.SwapChain = swapChain; }
private void canvasControl_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { modeInstance = null; args.TrackAsyncAction(canvasControl_CreateResourcesAsync(sender).AsAsyncAction()); var checks = CanvasBitmap.CreateFromColors(sender, new Color[] { Colors.Gray, Colors.Black, Colors.Black, Colors.Gray }, 2, 2); checkedFillPattern = new CanvasImageBrush(sender, checks) { ExtendX = CanvasEdgeBehavior.Wrap, ExtendY = CanvasEdgeBehavior.Wrap, Transform = Matrix3x2.CreateScale(16), Interpolation = CanvasImageInterpolation.NearestNeighbor }; }
private async Task CreateResourcesAsync(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { ServiceLocator.Current.GetInstance <ResourceProvider>().Initialize(Canvas); var dissolver = new Dissolver(this); await dissolver.CreateResources(); foreach (var xamlDrawer in Drawers) { var drawer = await xamlDrawer.CreateDrawerAsync(this, dissolver); drawer.TransitionTime = TransitionTime; await drawer.CreateResourcesAsync(sender, args); _drawers.Add(drawer); } }
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 }); } }
void canvasControl_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { if (!svgSupported) { return; } if (ThumbnailGenerator.IsDrawingThumbnail) { LoadSampleFile(); } else { CreateSomeSimplePlaceholderDocument(); } }
private void BackgroundCanvas32_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Task.Run(async() => { // Load the background image and create an image brush from it backgroundImage32 = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///Assets/CheckboardPattern_3264.png")); backgroundBrush32 = new CanvasImageBrush(sender, backgroundImage32) { Opacity = 0.3f }; // Set the brush's edge behaviour to wrap, so the image repeats if the drawn region is too big backgroundBrush32.ExtendX = backgroundBrush32.ExtendY = CanvasEdgeBehavior.Wrap; //this.resourcesLoaded32 = true; }).AsAsyncAction()); }
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); _slideLeftImplicitAnimationCollection = _c.CreateImplicitAnimationCollection(); var slideLeftAnim = _c.GenerateVector2KeyFrameAnimation() .HavingDuration(700) .ForTarget(() => _c.CreateSpriteShape().Offset); slideLeftAnim.InsertFinalValueKeyFrame(1f, _c.CreateEaseInOutBackEasingFunction()); _slideLeftImplicitAnimationCollection["Offset"] = slideLeftAnim.Animation; _slideRightImplicitAnimationCollection = _c.CreateImplicitAnimationCollection(); var slideRightAnim = _c.GenerateVector2KeyFrameAnimation() .HavingDuration(2000) .ForTarget(() => _c.CreateSpriteShape().Offset); slideRightAnim.InsertFinalValueKeyFrame(1f, _c.CreateEaseInOutBackEasingFunction()); _slideRightImplicitAnimationCollection["Offset"] = slideRightAnim.Animation; for (var i = 0; i < MaxShapeCount; i++) { var shape = _c.CreateSpriteShape(_c.CreatePathGeometry(GetClip(_rootSize))); shape.Offset = HideOffset; shape.FillBrush = _c.CreateColorBrush(_colors[i]); _rootShape.Shapes.Add(shape); } _selIndex = MaxShapeCount; _rootShape.Shapes[_selIndex].Offset = Vector2.Zero; ElementCompositionPreview.SetElementChildVisual(RenderGrid, _rootShape); PrevBtn.IsEnabled = false; }
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); }
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 OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { if (_bitmap != null) { _bitmap.Dispose(); } var buffer = ArrayPool <byte> .Shared.Rent(256 * 256 * 4); _bitmap = CanvasBitmap.CreateFromBytes(sender, buffer, _frameSize.Width, _frameSize.Height, DirectXPixelFormat.B8G8R8A8UIntNormalized); ArrayPool <byte> .Shared.Return(buffer); if (args.Reason == CanvasCreateResourcesReason.FirstTime) { OnSourceChanged(UriToPath(Source), _source); Invalidate(); } }
private void OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Task.Run(() => { var animation = VideoAnimation.LoadFromFile(_source, false, true); if (animation == null) { return; } _animation = animation; var colors = new byte[_animation.PixelWidth * _animation.PixelHeight * 4]; _bitmap = CanvasBitmap.CreateFromBytes(sender, colors, _animation.PixelWidth, _animation.PixelHeight, Windows.Graphics.DirectX.DirectXPixelFormat.R8G8B8A8UIntNormalized); _device = sender; }).AsAsyncAction()); }
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { attractor = new Attractor(canvas.Size); // 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); }
private void OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { lock (_reusableLock) { if (_reusableBuffer == null) { _reusableBuffer = new byte[256 * 256 * 4]; } } _device = sender; _bitmap = CanvasBitmap.CreateFromBytes(sender, _reusableBuffer, 256, 256, DirectXPixelFormat.B8G8R8A8UIntNormalized); if (args.Reason == CanvasCreateResourcesReason.FirstTime) { OnSourceChanged(UriToPath(Source), _source); Invalidate(); } }
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 Log.i(this, "CreateResources starting parallel task for creating textures"); args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction()); Log.i(this, "CreateResources finished"); }
void canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { switch (args.Reason) { case CanvasCreateResourcesReason.FirstTime: // First time initialization: either restore suspended app state, load a // photo that was passed in from the shell, or bring up the file selector. if (launchArg is ApplicationExecutionState && (ApplicationExecutionState)launchArg == ApplicationExecutionState.Terminated) { var restoreTask = RestoreSuspendedState(sender.Device); args.TrackAsyncAction(restoreTask.AsAsyncAction()); } else { if (!TryLoadPhoto(launchArg as IReadOnlyList <IStorageItem>)) { LoadButton_Click(null, null); } } break; case CanvasCreateResourcesReason.NewDevice: // Recovering after a lost device (GPU reset). if (photo.SourceBitmap != null) { photo.RecoverAfterDeviceLost(sender.Device); } cachedImage.RecoverAfterDeviceLost(); break; case CanvasCreateResourcesReason.DpiChanged: // We mostly work in pixels rather than DIPs, so only need // minimal layout updates in response to DPI changes. if (photo.SourceBitmap != null) { ZoomToFitPhoto(); } break; } }
void canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { switch (args.Reason) { case CanvasCreateResourcesReason.FirstTime: // First time initialization: either restore suspended app state, load a // photo that was passed in from the shell, or bring up the file selector. if (launchArg is ApplicationExecutionState && (ApplicationExecutionState)launchArg == ApplicationExecutionState.Terminated) { var restoreTask = RestoreSuspendedState(sender.Device); args.TrackAsyncAction(restoreTask.AsAsyncAction()); } else { if (!TryLoadPhoto(launchArg as IReadOnlyList<IStorageItem>)) { LoadButton_Click(null, null); } } break; case CanvasCreateResourcesReason.NewDevice: // Recovering after a lost device (GPU reset). if (photo.SourceBitmap != null) { photo.RecoverAfterDeviceLost(sender.Device); } cachedImage.RecoverAfterDeviceLost(); break; case CanvasCreateResourcesReason.DpiChanged: // We mostly work in pixels rather than DIPs, so only need // minimal layout updates in response to DPI changes. if (photo.SourceBitmap != null) { ZoomToFitPhoto(); } break; } }
private void canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { CanvasCommandList cl = new CanvasCommandList(sender); using (CanvasDrawingSession clds = cl.CreateDrawingSession()) { for (int i = 0; i < 100; i++) { clds.DrawText("Hello, World!", RndPosition(), Color.FromArgb(255, RndByte(), RndByte(), RndByte())); clds.DrawCircle(RndPosition(), RndRadius(), Color.FromArgb(255, RndByte(), RndByte(), RndByte())); clds.DrawLine(RndPosition(), RndPosition(), Color.FromArgb(255, RndByte(), RndByte(), RndByte())); } } blur = new GaussianBlurEffect() { Source = cl, BlurAmount = 10.0f }; }
private void _TextOverlaysCanvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { CanvasPathBuilder pathBuilder = new CanvasPathBuilder(sender); pathBuilder.BeginFigure(0, 2.5f); pathBuilder.AddLine(2, 0); pathBuilder.AddLine(6, 4); pathBuilder.AddLine(10, 0); pathBuilder.AddLine(14, 4); pathBuilder.AddLine(18, 0); pathBuilder.AddLine(22, 4); pathBuilder.AddLine(24, 1.5f); pathBuilder.EndFigure(CanvasFigureLoop.Open); CanvasGeometry canvasGeometry = CanvasGeometry.CreatePath(pathBuilder); _SquigglyLineGeometry = CanvasCachedGeometry.CreateStroke(canvasGeometry, 1); CreateOverlayResources?.Invoke(sender, args); }
private async void canvasMain_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { await Debug.Initialize(); await Statics.Initialize(canvasMain); await Map.Initialize(sender.Device); CanvasBitmap characterMap = await CanvasBitmap.LoadAsync(sender, "images/characters.png"); int maxX = 1920 / Map.TILE_RESOLUTION; int maxY = 1080 / Map.TILE_RESOLUTION; for (int i = 0; i < 500; i++) { int x = Random.Next(maxX) * Map.TILE_RESOLUTION; int y = Random.Next(maxY) * Map.TILE_RESOLUTION; Sprites.Add(new Sprite(characterMap, 64, new PointInt(x, y))); } }
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); }
// called when the CanvasAnimatedControl control first starts drawing. void drawingBoard_Setup(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { var filelocation = new Uri("ms-appx:///Assets/Pictures/lauren_mayberry.jpg"); //343 × 515 // previously: // lauren = await CanvasBitmap.LoadAsync(sender, filelocation); lauren = CanvasBitmap.LoadAsync(sender, filelocation).AsTask().Result; _blur = new GaussianBlurEffect { BlurAmount = 3.0f, Source = lauren }; lauren_brush = new CanvasImageBrush(sender, _blur) { SourceRectangle = new Rect(0, 0, 343, 343), // I have no idea about these params. Opacity = 0.9f, ExtendX = CanvasEdgeBehavior.Wrap, ExtendY = CanvasEdgeBehavior.Wrap }; }
private void OnWin2DCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { var effect1 = new GaussianBlurEffect() { BlurAmount = 20f, }; effect = effect1; var effect2 = new ColorMatrixEffect() { ColorMatrix = new Matrix5x4() { M11 = 1, M12 = 0, M13 = 0, M14 = 0, M21 = 0, M22 = 1, M23 = 0, M24 = 0, M31 = 0, M32 = 0, M33 = 1, M34 = 0, M41 = 0, M42 = 0, M43 = 0, M44 = 18, M51 = 0, M52 = 0, M53 = 0, M54 = -7, }, Source = effect1 }; image = effect2; }
void CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { if (args.Reason == CanvasCreateResourcesReason.DpiChanged) { return; } if (args.Reason == CanvasCreateResourcesReason.FirstTime) { bool spriteBatchSupported = CanvasSpriteBatch.IsSupported(sender.Device); UseSpriteBatch = spriteBatchSupported; if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs("UseSpriteBatch")); } UseSpriteBatchCheckBox.Visibility = spriteBatchSupported ? Visibility.Visible : Visibility.Collapsed; } args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction()); }
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 OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Task.Run(() => { var animation = VideoAnimation.LoadFromFile(_source, false, true); if (animation == null) { return; } _animation = animation; lock (_reusableLock) { if (_reusableBuffer == null || _reusableBuffer.Length < _animation.PixelWidth * _animation.PixelHeight * 4) { _reusableBuffer = new byte[_animation.PixelWidth * _animation.PixelHeight * 4]; } } _bitmap = CanvasBitmap.CreateFromBytes(sender, _reusableBuffer, _animation.PixelWidth, _animation.PixelHeight, DirectXPixelFormat.R8G8B8A8UIntNormalized); _device = sender; }).AsAsyncAction()); }
private void OnCanvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { var geom1 = CanvasObject.CreateGeometry(sender, "O 116 116 128 128"); var fill1 = CanvasObject.CreateBrush(sender, "SC #00adef"); var stroke1 = CanvasObject.CreateStroke(sender, "ST 8 SC #2a388f"); _layer1 = new CanvasRenderLayer(geom1, fill1, stroke1); var geom2 = CanvasObject.CreateGeometry(sender, "U 56 56 64 64 8 8"); var fill2 = CanvasObject.CreateBrush(sender, "SC #ed1c24"); var stroke2 = CanvasObject.CreateStroke(sender, "ST 2 SC #404041"); _layer2 = new CanvasRenderLayer(geom2, fill2, stroke2); var geom3 = CanvasObject.CreateGeometry(sender, "U 136 56 64 64 8 8"); var fill3 = CanvasObject.CreateBrush(sender, "SC #38b449"); _layer3 = new CanvasRenderLayer(geom3, fill3, stroke2); var geom4 = CanvasObject.CreateGeometry(sender, "U 56 136 64 64 8 8"); var fill4 = CanvasObject.CreateBrush(sender, "SC #fff100"); _layer4 = new CanvasRenderLayer(geom4, fill4, stroke2); var geom5 = CanvasObject.CreateGeometry(sender, "R 96 96 64 64"); var fill5 = CanvasObject.CreateBrush(sender, "SC #f7931d"); _layer5 = new CanvasRenderLayer(geom5, fill5, stroke2); var layers = new List <CanvasRenderLayer> { _layer1, _layer2, _layer3, _layer4, _layer5 }; _element = new CanvasElement(256f, 256f, layers); _isInitialized = true; }
private void Logo_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Task.Run(async() => { try { // Load the background image and create an image brush from it //var asset = new Uri("ms-appx:///Assets/Square71x71Logo.scale-200.png"); Uri asset = new Uri("ms-appx:///Assets/AppLogo.png"); if (asset != null && asset is Uri) { logoImage = await CanvasBitmap.LoadAsync(sender, asset); } else { logoImage = null; } } catch (Exception ex) { ex.Message.T().ShowMessage("ERROR".T()); } }).AsAsyncAction()); }
private void OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { lock (_reusableLock) { if (_reusableBuffer == null) { _reusableBuffer = new byte[256 * 256 * 4]; } } _device = sender; _bitmaps = new CanvasBitmap[_parts]; //for (int i = 0; i < _bitmaps.Length; i++) //{ // _bitmaps[i] = CanvasBitmap.CreateFromBytes(sender, _reusableBuffer, _frameSize.Width, _frameSize.Height, DirectXPixelFormat.B8G8R8A8UIntNormalized); //} if (args.Reason == CanvasCreateResourcesReason.FirstTime) { SetValue(_previousState, _previous); Invalidate(); } }
void Canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Canvas_CreateResourcesAsync(sender).AsAsyncAction()); }
void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { spriteBatchSupported = CanvasSpriteBatch.IsSupported(sender.Device); if (!spriteBatchSupported) return; args.TrackAsyncAction(LoadImages(sender.Device).AsAsyncAction()); }
void AnimatedCanvas_CreateResources(ICanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(LoadAnimatedCanvasResources(sender).AsAsyncAction()); }
private async Task Canvas_CreateResourcesAsync(CanvasControl sender, CanvasCreateResourcesEventArgs args) { _bitmap = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///Assets/menu_background.jpg")); }
private void Canvas_CreateResources( CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { this.initialized = true; }
void DriveCanvas_CreateResourcesEvent(CanvasControl control, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(DriveCanvas_CreateResourcesAsync(control).AsAsyncAction()); }
//private async void Save() //{ // //var fileName = "DrawingBoard" + DateTime.Now.ToString("yyyy-MM-dd_hh-mm-ss") + ".png"; // //var storageFolder = KnownFolders.PicturesLibrary; // //var sampleFile = await storageFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); // //using (var stream = await sampleFile.OpenAsync(FileAccessMode.ReadWrite)) // //{ // // await _layer.SaveAsync(stream, CanvasBitmapFileFormat.Png); // //} //} private void DrawingControl_OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { _renderer.CreateResourcesAsync(DrawingControl); }
private void Canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { needsResourceRecreation = true; args.TrackAsyncAction(Canvas_CreateResourcesAsync(sender).AsAsyncAction()); }
private void canvasMain_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(CreateResourcesAsync(sender).AsAsyncAction()); }
private void Canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { _effect = new GaussianBlurEffect() { BlurAmount = 5, BorderMode = EffectBorderMode.Hard }; }
private void canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { arrow = MakeDirectionIcon(sender); var bounds = arrow.ComputeStrokeBounds(3); var outline = arrow.Stroke(2).Outline(); var foregroundBrush = (SolidColorBrush)directionsCombo.Foreground; var color = foregroundBrush.Color; Directions = new List<DirectionInfo>(); foreach (CanvasTextDirection direction in Enum.GetValues(typeof(CanvasTextDirection))) { var arrowImage = new CanvasImageSource(sender, 64, 64); using (var ds = arrowImage.CreateDrawingSession(Colors.Transparent)) { var directionTransform = GetDirectionTransform(direction); ds.Transform = directionTransform * Matrix3x2.CreateTranslation((float)(32 - bounds.Width / 2), (float)(32 - bounds.Height / 2)); ds.DrawGeometry(arrow, color, 1); } Directions.Add(new DirectionInfo(direction, arrowImage)); } // Poke the property so that the control gets a chance to pick up the new images if (PropertyChanged != null) { PropertyChanged.Invoke(this, new PropertyChangedEventArgs("Directions")); PropertyChanged.Invoke(this, new PropertyChangedEventArgs("CurrentDirectionIndex")); } }
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Canvas_CreateResourcesAsync(sender).AsAsyncAction()); }
private void CanvasAnimatedControl_OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { CanvasAnimatedControl.SizeChanged += CanvasAnimatedControl_SizeChanged; Resize(sender); }
private void Canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(LoadBackgroundAsync(sender).AsAsyncAction()); }
virtual protected void Stage_CreateResources( CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args ) { args.TrackAsyncAction( LoadTextures( sender ).AsAsyncAction() ); }
void canvas_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { }
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 OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { if (args.Reason != CanvasCreateResourcesReason.DpiChanged) args.TrackAsyncAction(LoadSpritesAsync(sender).AsAsyncAction()); }