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;
}
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
};
}
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);
}
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);
}
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 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 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)
{
}
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 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());
}
