コード例 #1
0
        public void SetVideoSurface(IVideoSurface videoSurface)
        {
            if (!(videoSurface is VideoSurface))
            {
                throw new ArgumentException("Not a valid video surface");
            }

            var canvas = (VideoSurface)videoSurface;

            RenderSurface = canvas;

            var size = new Size(canvas.ActualWidth, canvas.ActualHeight);

            _player.SetSurfaceSize(size);

            var compositor = ElementCompositionPreview.GetElementVisual(canvas).Compositor;
            var surface    = _player.GetSurface(compositor);

            _spriteVisual      = compositor.CreateSpriteVisual();
            _spriteVisual.Size =
                new Vector2((float)canvas.ActualWidth, (float)canvas.ActualHeight);

            CompositionBrush brush = compositor.CreateSurfaceBrush(surface.CompositionSurface);

            _spriteVisual.Brush = brush;

            var container = compositor.CreateContainerVisual();

            container.Children.InsertAtTop(_spriteVisual);

            ElementCompositionPreview.SetElementChildVisual(canvas, container);
        }
コード例 #2
0
        private SpriteVisual SetupStageSide(StageSide side)
        {
            SpriteVisual     visual  = _compositor.CreateSpriteVisual();
            Vector3          offset  = Vector3.Zero;
            Vector2          size    = Vector2.Zero;
            CompositionBrush brush   = null;
            string           comment = string.Empty;

            switch (side)
            {
            case StageSide.Backdrop:
                offset  = new Vector3(_stageWidth / 2, _stageBackdropHeight / 2, -1 * _stageFloorDepth);
                size    = new Vector2(_stageWidth, _stageBackdropHeight);
                brush   = _compositor.CreateSurfaceBrush(_surfaceFactory.CreateUriSurface(new Uri(BackgropImage), new Size(_stageWidth, _stageBackdropHeight)).Surface);
                comment = "Backdrop";
                break;

            case StageSide.Floor:
                offset  = new Vector3(_stageWidth / 2, _stageBackdropHeight * 1.5f, -1 * _stageFloorDepth);
                size    = new Vector2(_stageWidth, _stageFloorDepth);
                brush   = _compositor.CreateSurfaceBrush(_surfaceFactory.CreateUriSurface(new Uri(FloorImage), new Size(_stageWidth, _stageFloorDepth)).Surface);
                comment = "Floor";
                visual.RotationAngleInDegrees = 90f;
                visual.RotationAxis           = _rotationAxisX;
                break;
            }

            visual.Offset  = offset;
            visual.Size    = size;
            visual.Brush   = brush;
            visual.Comment = comment;

            _stageContainer.Children.InsertAtTop(visual);
            return(visual);
        }
コード例 #3
0
        public void Remove()
        {
            // Remove effect

            if (null != this._foregroundElement)
            {
                this._foregroundElement.Opacity = 1.0f;
            }

            if (null != this._blurVisual)
            {
                this._blurVisual.Brush = null;
                this._blurVisual?.StopAnimation("Size");
            }

            this._bindSizeAnimation?.Dispose();
            this._bindSizeAnimation = null;

            this._effectBrush?.Dispose();
            this._effectBrush = null;

            this._backdropBrush?.Dispose();
            this._backdropBrush = null;

            this._blurEffect?.Dispose();
            this._blurEffect = null;

            // NOTE: No API to remove the child visual
            //this._blurVisual?.Dispose();
            //this._blurVisual = null;
        }
コード例 #4
0
 private void ClearResources()
 {
     _imageBrush?.Dispose();
     _imageBrush = null;
     _surfaceSource?.Dispose();
     _surfaceSource = null;
 }
コード例 #5
0
ファイル: BackDrop.cs プロジェクト: yueyz818/vlc-winrt
        public BackDrop()
        {
            m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement);
            Compositor   = m_rootVisual.Compositor;

            m_blurVisual = Compositor.CreateSpriteVisual();


            if (ApiInformation.IsMethodPresent("Windows.UI.Composition.Compositor", "CreateBackdropBrush"))
            {
                var brush = BuildBlurBrush();
                brush.SetSourceParameter("source", Compositor.CreateBackdropBrush());
                m_blurBrush        = brush;
                m_blurVisual.Brush = m_blurBrush;
            }
            else
            {
                m_blurBrush        = Compositor.CreateColorBrush(Colors.Black);
                m_blurVisual.Brush = m_blurBrush;
            }

            ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual);

            this.Loading  += OnLoading;
            this.Unloaded += OnUnloaded;
        }
コード例 #6
0
        private void UpdateShadowMask()
        {
            if (_castingElement != null)
            {
                CompositionBrush mask = null;
                if (_castingElement is Image)
                {
                    mask = ((Image)_castingElement).GetAlphaMask();
                }
                else if (_castingElement is Shape)
                {
                    mask = ((Shape)_castingElement).GetAlphaMask();
                }
                else if (_castingElement is TextBlock)
                {
                    mask = ((TextBlock)_castingElement).GetAlphaMask();
                }

                _dropShadow.Mask = mask;
            }
            else
            {
                _dropShadow.Mask = null;
            }
        }
コード例 #7
0
        private void InitializeDropShadow(UIElement shadowHost, CompositionBrush shadowTargetBrush)
        {
            Visual     hostVisual = ElementCompositionPreview.GetElementVisual(shadowHost);
            Compositor compositor = hostVisual.Compositor;

            // Create a drop shadow
            var dropShadow = compositor.CreateDropShadow();

            dropShadow.Color      = Color.FromArgb(102, 0, 0, 0);
            dropShadow.BlurRadius = 4.0f;
            // Associate the shape of the shadow with the shape of the target element
            dropShadow.Mask = shadowTargetBrush;

            // Create a Visual to hold the shadow
            var shadowVisual = compositor.CreateSpriteVisual();

            shadowVisual.Shadow = dropShadow;

            // Add the shadow as a child of the host in the visual tree
            ElementCompositionPreview.SetElementChildVisual(shadowHost, shadowVisual);

            // Make sure size of shadow host and shadow visual always stay in sync
            var bindSizeAnimation = compositor.CreateExpressionAnimation("hostVisual.Size");

            bindSizeAnimation.SetReferenceParameter("hostVisual", hostVisual);

            shadowVisual.StartAnimation("Size", bindSizeAnimation);
        }
コード例 #8
0
ファイル: BackDrop.cs プロジェクト: RomanGL/VKSaver
        public BackDrop()
        {
#if DEBUG
            if (DesignMode.DesignModeEnabled)
            {
                return;
            }
#endif

            m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement);
            Compositor   = m_rootVisual.Compositor;

            m_blurVisual = Compositor.CreateSpriteVisual();
            m_noiseBrush = Compositor.CreateSurfaceBrush();

            CompositionEffectBrush brush = BuildBlurBrush();
            brush.SetSourceParameter("source", m_compositor.CreateBackdropBrush());
            m_blurBrush        = brush;
            m_blurVisual.Brush = m_blurBrush;

            BlurAmount = 9;
            TintColor  = Colors.Transparent;
            ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual);

            this.Loading  += OnLoading;
            this.Unloaded += OnUnloaded;
        }
コード例 #9
0
ファイル: BackdropBlurBrush.cs プロジェクト: asvegah/FakePOS
        protected override void OnConnected()
        {
            // Delay creating composition resources until they're required.
            if (CompositionBrush == null)
            {
                var backdrop = Window.Current.Compositor.CreateBackdropBrush();

                // Use a Win2D blur affect applied to a CompositionBackdropBrush.
                var graphicsEffect = new GaussianBlurEffect
                {
                    Name       = "Blur",
                    BlurAmount = (float)this.BlurAmount,
                    Source     = new CompositionEffectSourceParameter("backdrop")
                };

                var effectFactory = Window.Current.Compositor.CreateEffectFactory(graphicsEffect, new[] { "Blur.BlurAmount" });
                var effectBrush   = effectFactory.CreateBrush();
                effectBrush.SetSourceParameter("backdrop", backdrop);

                CompositionBrush = effectBrush;
                if (BlurAmountExpression != null)
                {
                    CompositionBrush.StartAnimation("Blur.BlurAmount", BlurAmountExpression);
                }
            }
        }
コード例 #10
0
        /// <summary>
        /// Initializes new instance of the <see cref="BaseBackDrop"/> class.
        /// </summary>
        /// <param name="useHostBackdrop">Enables host backdrop is platform supports it.</param>
        public BaseBackDrop(bool useHostBackdrop = false)
        {
            m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement);
            Compositor   = m_rootVisual.Compositor;

            m_blurVisual = Compositor.CreateSpriteVisual();
            m_noiseBrush = Compositor.CreateSurfaceBrush();

            CompositionEffectBrush brush = BuildBlurBrush();

            if (useHostBackdrop && IsHostBackDropSupported)
            {
                brush.SetSourceParameter("source", m_compositor.CreateHostBackdropBrush());
            }
            else
            {
                brush.SetSourceParameter("source", m_compositor.CreateBackdropBrush());
            }

            m_blurBrush        = brush;
            m_blurVisual.Brush = m_blurBrush;

            BlurAmount = 9;
            //TintColor = Colors.Transparent;
            ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual);

            this.Loading  += OnLoading;
            this.Unloaded += OnUnloaded;
        }
コード例 #11
0
        private void UpdateShadowMask()
        {
            if (shadowVisual == null || !(shadowVisual.Brush is CompositionEffectBrush effectBrush))
            {
                return;
            }
            CompositionBrush newMask = null;

            if (IsMasked && Mask != null)
            {
                newMask = Mask;
            }
            else if (IsMasked && Content != null)
            {
                if (Content is Image)
                {
                    newMask = ((Image)Content).GetAlphaMask();
                }
                else if (Content is Shape)
                {
                    newMask = ((Shape)Content).GetAlphaMask();
                }
                else if (Content is TextBlock)
                {
                    newMask = ((TextBlock)Content).GetAlphaMask();
                }
            }
            try {
                effectBrush.SetSourceParameter(effectSourceName, newMask);
            } catch (Exception) { }
        }
コード例 #12
0
        private void SetImageUri()
        {
            ClearResources();

            if (ImageUri == null)
            {
                return;
            }

            var uri = ImageUri;

            try
            {
                var src = CreateSurface();
                _surfaceSource = src as IDisposable;
                var surfaceBrush = _compositor.CreateSurfaceBrush(src);
                surfaceBrush.VerticalAlignmentRatio   = 0.0f;
                surfaceBrush.HorizontalAlignmentRatio = 0.0f;
                surfaceBrush.Stretch = CompositionStretch.None;
                _imageBrush          = surfaceBrush;

                UpdateBrush();
            }
            catch
            {
                // no image for you, soz.
            }
        }
コード例 #13
0
        public CompositionImage()
        {
            this.DefaultStyleKey = typeof(CompositionImage);
            this.Background      = new SolidColorBrush(Colors.Transparent);
            this._stretchMode    = CompositionStretch.Uniform;
            this.Loading        += CompImage_Loading;
            this.Unloaded       += CompImage_Unloaded;
            this.SizeChanged    += CompImage_SizeChanged;

            _compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;

            // Intialize the statics as needed
            if (!_staticsInitialized)
            {
                _defaultPlaceholderBrush = _compositor.CreateColorBrush(Colors.DarkGray);

                TimeSpan duration = TimeSpan.FromMilliseconds(1000);
                _fadeOutAnimation = _compositor.CreateScalarKeyFrameAnimation();
                _fadeOutAnimation.InsertKeyFrame(0, 1);
                _fadeOutAnimation.InsertKeyFrame(1, 0);
                _fadeOutAnimation.Duration = duration;

                _scaleAnimation = _compositor.CreateVector2KeyFrameAnimation();
                _scaleAnimation.InsertKeyFrame(0, new Vector2(1.25f, 1.25f));
                _scaleAnimation.InsertKeyFrame(1, new Vector2(1, 1));
                _scaleAnimation.Duration = duration;

                _staticsInitialized = true;
            }

            _placeholderDelay = TimeSpan.FromMilliseconds(50);
            _surfaceBrush     = _compositor.CreateSurfaceBrush(null);
        }
コード例 #14
0
        protected override void OnDisconnected()
        {
            if (CompositionBrush != null)
            {
                IsConnected = false;

                canvasDevice.Dispose();
                canvasDevice = null;
                graphicsDevice.Dispose();
                graphicsDevice = null;

                surfaceBrush1.Dispose();
                surfaceBrush1 = null;
                surfaceBrush2.Dispose();
                surfaceBrush2 = null;

                surface1.Dispose();
                surface1 = null;
                surface2.Dispose();
                surface2 = null;

                Source1Animation.Dispose();
                Source1Animation = null;
                Source2Animation.Dispose();
                Source2Animation = null;

                colorBrush1.Dispose();
                colorBrush1 = null;
                colorBrush2.Dispose();
                colorBrush2 = null;

                CompositionBrush.Dispose();
                CompositionBrush = null;
            }
        }
コード例 #15
0
 protected override void OnDisconnected()
 {
     CoreWindow.GetForCurrentThread().Activated         -= AcrylicBrush_Activated;
     CoreWindow.GetForCurrentThread().VisibilityChanged -= AcrylicBrush_VisibilityChanged;
     CompositionBrush.Dispose();
     CompositionBrush = null;
 }
コード例 #16
0
        private void UpdateShadowMask()
        {
            if (!IsSupported)
            {
                return;
            }

            if (Content != null)
            {
                CompositionBrush mask = null;
                if (Content is Image)
                {
                    mask = ((Image)Content).GetAlphaMask();
                }
                else if (Content is Shape)
                {
                    mask = ((Shape)Content).GetAlphaMask();
                }
                else if (Content is TextBlock)
                {
                    mask = ((TextBlock)Content).GetAlphaMask();
                }

                _dropShadow.Mask = mask;
            }
            else
            {
                _dropShadow.Mask = null;
            }
        }
コード例 #17
0
        internal CompositionBrush[] GeneratePerBarLinearGradient(int numBrushes, List <Color> colors)
        {
            var lgb = compositor.CreateLinearGradientBrush();

            lgb.RotationAngleInDegrees = 45;

            int i = 0;

            foreach (Color color in colors)
            {
                float offset = i / ((float)colors.Count - 1);
                var   stop   = compositor.CreateColorGradientStop(offset, color);

                i++;
                lgb.ColorStops.Add(stop);
            }

            var brushes = new CompositionBrush[numBrushes];

            for (int j = 0; j < numBrushes; j++)
            {
                brushes[j] = lgb;
            }
            return(brushes);
        }
コード例 #18
0
        protected override void OnAttached()
        {
            var blurAmount = (double)Element.GetValue(RoutingEffects.ViewBlur.BlurAmountProperty);

            rootVisual = ElementCompositionPreview.GetElementVisual(Container);

            Compositor = rootVisual.Compositor;

            blurVisual = Compositor.CreateSpriteVisual();

            var brush = BuildBlurBrush();

            brush.SetSourceParameter("source", Compositor.CreateBackdropBrush());
            blurBrush        = brush;
            blurVisual.Brush = blurBrush;

            ElementCompositionPreview.SetElementChildVisual(Container, blurVisual);

            Container.Loading  += OnLoading;
            Container.Unloaded += OnUnloaded;

            blurBrush.Properties.InsertScalar("Blur.BlurAmount", (float)blurAmount);
            rootVisual.Properties.InsertScalar("BlurAmount", (float)blurAmount);

            SetUpPropertySetExpressions();
        }
コード例 #19
0
        private void UpdateShadowMask()
        {
            if (Content != null && IsMasked)
            {
                CompositionBrush mask = null;

                if (Content is Image image)
                {
                    mask = image.GetAlphaMask();
                }
                else if (Content is Shape shape)
                {
                    mask = shape.GetAlphaMask();
                }
                else if (Content is TextBlock textBlock)
                {
                    mask = textBlock.GetAlphaMask();
                }

                _dropShadow.Mask = mask;
            }
            else
            {
                _dropShadow.Mask = null;
            }
        }
コード例 #20
0
        static public void SetBrush(this UIElement element, CompositionBrush brush)
        {
            var spriteVisual = CreateSpriteVisual(element);

            spriteVisual.Brush = brush;
            ElementCompositionPreview.SetElementChildVisual(element, spriteVisual);
        }
コード例 #21
0
        public BackDrop()
        {
            m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement);
            Compositor = m_rootVisual.Compositor;

            m_blurVisual = Compositor.CreateSpriteVisual();

#if SDKVERSION_INSIDER
            m_noiseBrush = Compositor.CreateSurfaceBrush();

            CompositionEffectBrush brush = BuildBlurBrush();
            brush.SetSourceParameter("source", m_compositor.CreateBackdropBrush());
            m_blurBrush = brush;
            m_blurVisual.Brush = m_blurBrush;

            BlurAmount = 9;
            TintColor = Colors.Transparent;
#else
            m_blurBrush = Compositor.CreateColorBrush(Colors.White);
            m_blurVisual.Brush = m_blurBrush;
#endif
            ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual);

            this.Loading += OnLoading;
            this.Unloaded += OnUnloaded;
        }
コード例 #22
0
        // Test noise cache is functional:
        // 1. Validate two AcrylicBrushes both use the same noise
        // 2. Validate destroying these AB's and creating a new one still use the same noise.
        void RunAcrylicNoiseCache()
        {
            AcrylicBrush acrylicBrush1 = new AcrylicBrush {
                BackgroundSource = AcrylicBackgroundSource.Backdrop,
                FallbackColor    = Colors.Blue,
                TintColor        = Colors.Green,
                TintOpacity      = 0.1
            };

            AcrylicBrush acrylicBrush2 = new AcrylicBrush {
                BackgroundSource = AcrylicBackgroundSource.Backdrop,
                FallbackColor    = Colors.Blue,
                TintColor        = Colors.Bisque,
                TintOpacity      = 1
            };

            Rectangle1.Fill = acrylicBrush1;
            _acrylicTestApi.AcrylicBrush = acrylicBrush1;
            CompositionBrush noiseBrush1 = UpdateNoiseBrush();

            if (_acrylicTestApi.IsUsingAcrylicBrush == false)
            {
                TestResult.Text = "AcrylicNoiseCache: Skipped";
                return;
            }

            Rectangle1.Stroke            = acrylicBrush2;
            _acrylicTestApi.AcrylicBrush = acrylicBrush2;
            CompositionBrush noiseBrush2 = UpdateNoiseBrush();

            // Make sure two brushes conccurrently in tree use the same noise
            bool result1 = Object.ReferenceEquals(noiseBrush1, noiseBrush2);

            // Destroy existing brushes
            Rectangle1.Fill              = new SolidColorBrush(Colors.PaleGoldenrod);
            Rectangle1.Stroke            = new SolidColorBrush(Colors.PaleGoldenrod);
            acrylicBrush1                = null;
            acrylicBrush2                = null;
            _acrylicTestApi.AcrylicBrush = null;
            GC.Collect();

            AcrylicBrush acrylicBrush3 = new AcrylicBrush {
                BackgroundSource = AcrylicBackgroundSource.Backdrop,
                FallbackColor    = Colors.Blue,
                TintColor        = Colors.DarkOliveGreen,
                TintOpacity      = 0.25
            };

            Rectangle1.Fill = acrylicBrush3;
            _acrylicTestApi.AcrylicBrush = acrylicBrush3;
            CompositionBrush noiseBrush3 = UpdateNoiseBrush();

            // Make sure new brush still uses the same noise
            bool result2 = Object.ReferenceEquals(noiseBrush2, noiseBrush3);

            bool   result       = result1 && result2;
            string resultString = System.String.Format("({0},{1})", result1, result2);

            TestResult.Text = "AcrylicNoiseCache: " + (result ? "Passed" : ("Failed " + resultString));
        }
コード例 #23
0
        public BackDrop()
        {
            m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement);
            Compositor   = m_rootVisual.Compositor;

            m_blurVisual = Compositor.CreateSpriteVisual();

#if SDKVERSION_14393
            m_noiseBrush = Compositor.CreateSurfaceBrush();

            CompositionEffectBrush brush = BuildBlurBrush();
            brush.SetSourceParameter("source", m_compositor.CreateBackdropBrush());
            m_blurBrush        = brush;
            m_blurVisual.Brush = m_blurBrush;

            BlurAmount = 9;
            TintColor  = Colors.Transparent;
#else
            m_blurBrush        = Compositor.CreateColorBrush(Colors.White);
            m_blurVisual.Brush = m_blurBrush;
#endif
            ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual);

            this.Loading  += OnLoading;
            this.Unloaded += OnUnloaded;
        }
コード例 #24
0
        private static CompositionBrush CreateBlurBrush()
        {
            if (_blurBrush != null)
            {
                return(_blurBrush);
            }
            var blurEffect = new GaussianBlurEffect
            {
                Name         = "Blur",
                BlurAmount   = 15.0f,
                BorderMode   = EffectBorderMode.Hard,
                Optimization = EffectOptimization.Balanced,
                Source       = new CompositionEffectSourceParameter("source")
            };

            var blendEffect = new BlendEffect
            {
                Background = blurEffect,
                Foreground = new ColorSourceEffect {
                    Name = "Color", Color = Color.FromArgb(64, 0, 0, 0)
                },
                Mode = BlendEffectMode.SoftLight
            };

            var blurEffectFactory = _compositor.CreateEffectFactory(blendEffect);
            var blurBrush         = blurEffectFactory.CreateBrush();

            var backdropBrush = _compositor.CreateBackdropBrush();

            blurBrush.SetSourceParameter("source", backdropBrush);

            _blurBrush = blurBrush;

            return(_blurBrush);
        }
コード例 #25
0
        /// <summary>
        /// Deconstructs the Composition Brush.
        /// </summary>
        protected override void OnDisconnected()
        {
            base.OnDisconnected();

            if (_device != null)
            {
                _device.DeviceLost -= CanvasDevice_DeviceLost;
                _device             = null;
            }

            if (_graphics != null)
            {
                _graphics.RenderingDeviceReplaced -= CanvasDevice_RenderingDeviceReplaced;
                _graphics = null;
            }

            // Dispose of composition resources when no longer in use.
            if (CompositionBrush != null)
            {
                CompositionBrush.Dispose();
                CompositionBrush = null;
            }

            if (_surfaceBrush != null)
            {
                _surfaceBrush.Dispose();
                _surfaceBrush = null;
            }
        }
コード例 #26
0
        protected override void OnDisconnected()
        {
            Window.Current.SizeChanged -= OnWindowSizeChanged;

            CompositionBrush?.Dispose();
            CompositionBrush = null;
        }
        async Task CreateTintEffectBrushAsync(Uri uri)
        {
            Xamarin.Forms.Image element = this.Element as Xamarin.Forms.Image;

            if (Control == null || Element == null || element.Width < 0 || element.Height < 0)
            {
                return;
            }

            SetupCompositor();

            spriteVisual      = compositor.CreateSpriteVisual();
            spriteVisual.Size = new Vector2((float)element.Width, (float)element.Height);

            imageSurface = await generator.CreateImageSurfaceAsync(uri, new Windows.Foundation.Size(element.Width, element.Height), ImageSurfaceOptions.DefaultOptimized);

            CompositionSurfaceBrush surfaceBrush = compositor.CreateSurfaceBrush(imageSurface.Surface);

            CompositionBrush targetBrush = surfaceBrush;

            if (this.TintColor == Color.Transparent)
            {
                // Don't apply tint effect
                effectBrush = null;
            }
            else
            {
                // Set target brush to tint effect brush

                Windows.UI.Color nativeColor = GetNativeColor(this.TintColor);

                IGraphicsEffect graphicsEffect = new CompositeEffect
                {
                    Mode    = CanvasComposite.DestinationIn,
                    Sources =
                    {
                        new ColorSourceEffect
                        {
                            Name  = "colorSource",
                            Color = nativeColor
                        },
                        new CompositionEffectSourceParameter("mask")
                    }
                };

                CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect,
                                                                                        new[] { "colorSource.Color" });

                effectBrush = effectFactory.CreateBrush();
                effectBrush.SetSourceParameter("mask", surfaceBrush);

                SetTint(nativeColor);

                targetBrush = effectBrush;
            }

            spriteVisual.Brush = targetBrush;
            ElementCompositionPreview.SetElementChildVisual(Control, spriteVisual);
        }
コード例 #28
0
        private void ApplyInternal(
            float blurAmount)
        {
            // SOURCE: https://msdn.microsoft.com/en-us/windows/uwp/graphics/using-the-visual-layer-with-xaml

            // Get the host visual and compositor
            Visual     hostVisual = ElementCompositionPreview.GetElementVisual(this._foregroundElement);
            Compositor compositor = hostVisual.Compositor;

            // Create a blur effect
            this._blurEffect = new GaussianBlurEffect
            {
                BlurAmount = blurAmount,
                BorderMode = EffectBorderMode.Hard,
                //Source = new CompositionEffectSourceParameter("backdropBrush"),
                Source = new ArithmeticCompositeEffect
                {
                    MultiplyAmount = 0,
                    Source1Amount  = 0.5f,
                    Source2Amount  = 0.5f,
                    Source1        = new CompositionEffectSourceParameter("backdropBrush"),
                    Source2        = new ColorSourceEffect
                    {
                        Color = global::Windows.UI.Color.FromArgb(255, 0xee, 0xee, 0xee),
                    }
                }
            };

            //  Create an instance of the effect
            using (var effectFactory = compositor.CreateEffectFactory(this._blurEffect))
            {
                this._effectBrush = effectFactory.CreateBrush();
            }

            // Set the effect source to a CompositionBackdropBrush
            this._backdropBrush = compositor.CreateBackdropBrush();
            this._effectBrush.SetSourceParameter("backdropBrush", this._backdropBrush);

            // Get any existing child sprite visual
            this._blurVisual = (SpriteVisual)ElementCompositionPreview.GetElementChildVisual(this._foregroundElement);
            if (null == this._blurVisual)
            {
                // Create a sprite visual to contain the effect
                this._blurVisual       = compositor.CreateSpriteVisual();
                this._blurVisual.Brush = this._effectBrush;

                // Add the sprite visual as a child of the host visual in the visual tree
                ElementCompositionPreview.SetElementChildVisual(this._foregroundElement, this._blurVisual);
            }
            else
            {
                this._blurVisual.Brush = this._effectBrush;
            }

            // Make sure size of the host and effect visuals always stay in sync
            this._bindSizeAnimation = compositor.CreateExpressionAnimation("hostVisual.Size");
            this._bindSizeAnimation.SetReferenceParameter("hostVisual", hostVisual);
            this._blurVisual.StartAnimation("Size", this._bindSizeAnimation);
        }
コード例 #29
0
 private void ApplyForeground()
 {
     if (Foreground is SolidColorBrush solid)
     {
         _foreground = Window.Current.Compositor.CreateColorBrush(solid.Color);
         OnValueChanged(Value, Value);
     }
 }
コード例 #30
0
 protected override void OnDisconnected()
 {
     if (CompositionBrush != null)
     {
         CompositionBrush.Dispose();
         CompositionBrush = null;
     }
 }
コード例 #31
0
ファイル: BarGraph.cs プロジェクト: clarkezone/WinCompWPF
        private Bar[] CreateBars(float[] data)
        {
            //Clear hashmap
            barValueMap.Clear();


            // TODO break out into separate UpdateColors method?
            var barBrushHelper = new BarGraphUtility.BarBrushHelper(_compositor);

            CompositionBrush[] brushes = new CompositionBrush[data.Length];
            switch (_graphBarStyle)
            {
            case GraphBarStyle.Single:
                brushes = barBrushHelper.GenerateSingleColorBrush(data.Length, _graphBarColors[0]);
                break;

            case GraphBarStyle.Random:
                brushes = barBrushHelper.GenerateRandomColorBrushes(data.Length);
                break;

            case GraphBarStyle.PerBarLinearGradient:
                brushes = barBrushHelper.GeneratePerBarLinearGradient(data.Length, _graphBarColors);
                break;

            case GraphBarStyle.AmbientAnimatingPerBarLinearGradient:
                brushes = barBrushHelper.GenerateAmbientAnimatingPerBarLinearGradient(data.Length, _graphBarColors);
                break;

            case GraphBarStyle.SharedLinearGradient:
                brushes = barBrushHelper.GenerateSharedLinearGradient(data.Length);
                break;

            case GraphBarStyle.TintedBlur:
                brushes = barBrushHelper.GenerateTintedBlur(data.Length);
                break;

            default:
                brushes = barBrushHelper.GenerateSingleColorBrush(data.Length, _graphBarColors[0]);
                break;
            }

            var maxValue = GetMaxBarValue(data);
            var bars     = new Bar[data.Length];

            for (int i = 0; i < data.Length; i++)
            {
                var xOffset = _shapeGraphOffsetX + _barSpacing + (_barWidth + _barSpacing) * i;
                var height  = GetAdjustedBarHeight(maxValue, _graphData[i]);

                var bar = new BarGraphUtility.Bar(_compositor, _shapeGraphContainerHeight, height, _barWidth, "something", _graphData[i], brushes[i]);
                bar.Root.Offset = new System.Numerics.Vector3(xOffset, _shapeGraphContainerHeight + _shapeGraphOffsetY, 0);

                barValueMap.Add(i, bar);

                bars[i] = bar;
            }
            return(bars);
        }
コード例 #32
0
ファイル: CompositionImage.cs プロジェクト: liquidboy/X
        public CompositionImage()
        {
            this.DefaultStyleKey = typeof(CompositionImage);
            this.Background = new SolidColorBrush(Colors.Transparent);
            this._stretchMode = CompositionStretch.Uniform;
            this.Loading += CompImage_Loading;
            this.Unloaded += CompImage_Unloaded;
            this.SizeChanged += CompImage_SizeChanged;

            _compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;

            // Intialize the statics as needed
            if (!_staticsInitialized)
            {
                _defaultPlaceholderBrush = _compositor.CreateColorBrush(Colors.DarkGray);

                TimeSpan duration = TimeSpan.FromMilliseconds(1000);
                _fadeOutAnimation = _compositor.CreateScalarKeyFrameAnimation();
                _fadeOutAnimation.InsertKeyFrame(0, 1);
                _fadeOutAnimation.InsertKeyFrame(1, 0);
                _fadeOutAnimation.Duration = duration;

                _scaleAnimation = _compositor.CreateVector2KeyFrameAnimation();
                _scaleAnimation.InsertKeyFrame(0, new Vector2(1.25f, 1.25f));
                _scaleAnimation.InsertKeyFrame(1, new Vector2(1, 1));
                _scaleAnimation.Duration = duration;

                _staticsInitialized = true;
            }

            // Initialize the surface loader if needed
            if (!SurfaceLoader.IsInitialized)
            {
                SurfaceLoader.Initialize(ElementCompositionPreview.GetElementVisual(this).Compositor);
            }

            _placeholderDelay = TimeSpan.FromMilliseconds(50);
            _surfaceBrush = _compositor.CreateSurfaceBrush(null);
        }
コード例 #33
0
        private void SamplePage_Loaded(object sender, RoutedEventArgs e)
        {
            //get interop compositor
            _compositor = ElementCompositionPreview.GetElementVisual(MainGrid).Compositor;

            //get image brush and image visual
            _image = Image; 
            _imageVisual = _image.SpriteVisual;
            _imageBrush = _image.SurfaceBrush;

            //load height map to surface brush
            _imageLoader = ImageLoaderFactory.CreateImageLoader(_compositor);
            _normalMapSurface = _imageLoader.CreateManagedSurfaceFromUri(new Uri("ms-appx:///Samples/SDK Insider/ImageLightingPlayground/rocks_NM_height.png"));
            _normalMapBrush = _compositor.CreateSurfaceBrush();
            _normalMapBrush.Surface = _normalMapSurface.Surface;

            //set up lighting effects:

            // DISTANT DIFFUSE
            // Effect description
            var distantDiffuseDesc = new ArithmeticCompositeEffect
            {
                Source1 = new CompositionEffectSourceParameter("Image"),
                Source2 = new DistantDiffuseEffect
                {
                    Name = "light",
                    Source = new CompositionEffectSourceParameter("NormalMap")
                },
                Source1Amount = 0,
                Source2Amount = 0,
                MultiplyAmount = 1
            };

            //Create (Light)EffectBrush from EffectFactory and specify animatable properties
            _distantDiffuseLightBrush = _compositor.CreateEffectFactory(
                distantDiffuseDesc,
                new[]
                {
                    "light.Azimuth",
                    "light.Elevation",
                    "light.DiffuseAmount",
                    "light.LightColor"
                }
            ).CreateBrush();

            //set source parameters to image and normal map
            _distantDiffuseLightBrush.SetSourceParameter(
                "Image",
                _imageBrush);
            _distantDiffuseLightBrush.SetSourceParameter(
                "NormalMap",
                _normalMapBrush);

            // DISTANT SPECULAR
            // Effect description
            var distantSpecularDesc = new BlendEffect
            {
                Foreground = new CompositionEffectSourceParameter("Image"),
                Background = new DistantSpecularEffect
                {
                    Name = "light",
                    Source = new CompositionEffectSourceParameter("NormalMap")
                },
                Mode = BlendEffectMode.Screen
            };

            //Create (Light)EffectBrush from EffectFactory and specify animatable properties
            _distantSpecularLightBrush = _compositor.CreateEffectFactory(
                distantSpecularDesc,
                new[]
                {
                    "light.Azimuth",
                    "light.Elevation",
                    "light.SpecularExponent",
                    "light.SpecularAmount",
                    "light.LightColor"
                }
            ).CreateBrush();

            //set source parameters to image and normal map
            _distantSpecularLightBrush.SetSourceParameter(
                "Image",
                _imageBrush);
            _distantSpecularLightBrush.SetSourceParameter(
                "NormalMap",
                _normalMapBrush);

            // POINT DIFFUSE
            // Effect description
            var pointDiffuseDesc = new ArithmeticCompositeEffect
            {
                Source1 = new CompositionEffectSourceParameter("Image"),
                Source2 = new PointDiffuseEffect
                {
                    Name = "light",
                    Source = new CompositionEffectSourceParameter("NormalMap")
                },
                Source1Amount = 0,
                Source2Amount = 0,
                MultiplyAmount = 1
            };

            //Create (Light)EffectBrush from EffectFactory and specify animatable properties
            _pointDiffuseLightBrush = _compositor.CreateEffectFactory(
                pointDiffuseDesc,
                new[]
                {
                    "light.LightPosition",
                    "light.DiffuseAmount",
                    "light.HeightMapScale",
                    "light.LightColor"
                }
            ).CreateBrush();

            // set source parameters to image and normal map
            _pointDiffuseLightBrush.SetSourceParameter(
                "Image",
                _imageBrush);
            _pointDiffuseLightBrush.SetSourceParameter(
                "NormalMap",
               _normalMapBrush);

            // POINT SPECUALR
            // Effect description
            var pointSpecularDesc = new BlendEffect
            {
                Foreground = new CompositionEffectSourceParameter("Image"),
                Background = new PointSpecularEffect
                {
                    Name = "light",
                    Source = new CompositionEffectSourceParameter("NormalMap")
                },
                Mode = BlendEffectMode.Screen
            };

            //Create (Light)EffectBrush from EffectFactory and specify animatable properties
            _pointSpecularLightBrush = _compositor.CreateEffectFactory(
                pointSpecularDesc,
                new[]
                {
                    "light.LightPosition",
                    "light.SpecularExponent",
                    "light.SpecularAmount",
                    "light.HeightMapScale",
                    "light.LightColor"
                }
            ).CreateBrush();

            // set source parameters to image and normal map
            _pointSpecularLightBrush.SetSourceParameter(
                "Image",
                _imageBrush);
            _pointSpecularLightBrush.SetSourceParameter(
                "NormalMap",
               _normalMapBrush);

            //SPOT DIFFUSE
            // Effect description
            var spotDiffuseDesc = new ArithmeticCompositeEffect
            {
                Source1 = new CompositionEffectSourceParameter("Image"),
                Source2 = new SpotDiffuseEffect
                {
                    Name = "light",
                    Source = new CompositionEffectSourceParameter("NormalMap")
                },
                Source1Amount = 0,
                Source2Amount = 0,
                MultiplyAmount = 1
            };

            //Create (Light)EffectBrush from EffectFactory and specify animatable properties
            _spotDiffuseLightBrush = _compositor.CreateEffectFactory(
                spotDiffuseDesc,
                new[]
                {
                    "light.LightPosition",
                    "light.LightTarget",
                    "light.Focus",
                    "light.LimitingConeAngle",
                    "light.DiffuseAmount",
                    "light.HeightMapScale",
                    "light.LightColor"
                }
            ).CreateBrush();

            // set source parameters to image and normal map
            _spotDiffuseLightBrush.SetSourceParameter(
                "Image",
                _imageBrush);
            _spotDiffuseLightBrush.SetSourceParameter(
                "NormalMap",
                _normalMapBrush);

            // SPOT SPECULAR
            // Effect description
            var spotSpecularDesc = new BlendEffect
            {
                Foreground = new CompositionEffectSourceParameter("Image"),
                Background = new SpotSpecularEffect
                {
                    Name = "light",
                    Source = new CompositionEffectSourceParameter("NormalMap")
                },
                Mode = BlendEffectMode.Screen
            };

            //Create (Light)EffectBrush from EffectFactory
            _spotSpecularLightBrush = _compositor.CreateEffectFactory(
                spotSpecularDesc,
                new[]
                {
                    "light.LightPosition",
                    "light.LightTarget",
                    "light.Focus",
                    "light.LimitingConeAngle",
                    "light.SpecularExponent",
                    "light.SpecularAmount",
                    "light.HeightMapScale",
                    "light.LightColor"
                }
            ).CreateBrush();

            // set source parameters to image and normal map
            _spotSpecularLightBrush.SetSourceParameter(
                "Image",
                _imageBrush);
            _spotSpecularLightBrush.SetSourceParameter(
                "NormalMap",
                _normalMapBrush);

            // For simplying UI states switch, put light parameter grids in an array
            _lightParamsGrids = new Grid[(int)LightType.NumLightTypes];
            _lightParamsGrids[(int)LightType.NoLight] = null;
            _lightParamsGrids[(int)LightType.DistantDiffuse] = DistantDiffuseParams;
            _lightParamsGrids[(int)LightType.DistantSpecular] = DistantSpecularParams;
            _lightParamsGrids[(int)LightType.PointDiffuse] = PointDiffuseParams;
            _lightParamsGrids[(int)LightType.PointSpecular] = PointSpecularParams;
            _lightParamsGrids[(int)LightType.SpotDiffuse] = SpotDiffuseParams;
            _lightParamsGrids[(int)LightType.SpotSpecular] = SpotSpecularParams;

            // Same as grids
            _lightBrushes = new CompositionBrush[(int)LightType.NumLightTypes];
            _lightBrushes[(int)LightType.NoLight] = _imageBrush;
            _lightBrushes[(int)LightType.DistantDiffuse] = _distantDiffuseLightBrush;
            _lightBrushes[(int)LightType.DistantSpecular] = _distantSpecularLightBrush;
            _lightBrushes[(int)LightType.PointDiffuse] = _pointDiffuseLightBrush;
            _lightBrushes[(int)LightType.PointSpecular] = _pointSpecularLightBrush;
            _lightBrushes[(int)LightType.SpotDiffuse] = _spotDiffuseLightBrush;
            _lightBrushes[(int)LightType.SpotSpecular] = _spotSpecularLightBrush;

            //Initialize values for all light types
            InitializeValues();

            
        }
コード例 #34
0
        private void MainGridLoaded(object sender, RoutedEventArgs e)
        {
            m_compositor = ElementCompositionPreview.GetElementVisual(MainGrid).Compositor;
            m_root = m_compositor.CreateContainerVisual();
            ElementCompositionPreview.SetElementChildVisual(MainGrid, m_root);

            Size imageSize;
            m_noEffectBrush = CreateBrushFromAsset(
                "Bruno'sFamily2015 (13)-X2.jpg",
                out imageSize);
            m_imageAspectRatio = (imageSize.Width == 0 && imageSize.Height == 0) ? 1 : imageSize.Width / imageSize.Height;

            m_sprite = m_compositor.CreateSpriteVisual();
            ResizeImage(new Size(MainGrid.ActualWidth, MainGrid.ActualHeight));
            m_root.Children.InsertAtTop(m_sprite);

            // Image with alpha channel as an mask.
            var alphaMaskEffectDesc = new CompositeEffect
            {
                Mode = CanvasComposite.DestinationIn,
                Sources =
                {
                    new CompositionEffectSourceParameter("Image"),
                    new Transform2DEffect
                    {
                        Name = "MaskTransform",
                        Source = new CompositionEffectSourceParameter("Mask")
                    }
                }
            };
            m_alphaMaskEffectBrush = m_compositor.CreateEffectFactory(
                alphaMaskEffectDesc,
                new[] { "MaskTransform.TransformMatrix" }
            ).CreateBrush();
            m_alphaMaskEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);
            m_alphaMaskEffectBrush.SetSourceParameter(
                "Mask",
                CreateBrushFromAsset("CircleMask.png"));

            // Arithmetic operations between two images.
            var arithmeticEffectDesc = new ArithmeticCompositeEffect
            {
                Name = "effect",
                ClampOutput = false,
                Source1 = new CompositionEffectSourceParameter("Source1"),
                Source2 = new CompositionEffectSourceParameter("Source2")
            };
            m_arithmeticEffectBrush = m_compositor.CreateEffectFactory(
                arithmeticEffectDesc,
                new[]
                {
                    "effect.MultiplyAmount",
                    "effect.Source1Amount",
                    "effect.Source2Amount",
                    "effect.Offset"
                }
            ).CreateBrush();
            m_arithmeticEffectBrush.SetSourceParameter(
                "Source1",
                m_noEffectBrush);
            m_arithmeticEffectBrush.SetSourceParameter(
                "Source2",
                CreateBrushFromAsset("_P2A8041.jpg"));

            // Creates a blend effect that combines two images.
            var foregroundBrush = CreateBrushFromAsset("Checkerboard_100x100.png");
            m_blendEffectBrushes = new CompositionEffectBrush[m_supportedBlendModes.Length];
            for (int i = 0; i < m_supportedBlendModes.Length; i++)
            {
                var blendEffectDesc = new BlendEffect
                {
                    Mode = m_supportedBlendModes[i],
                    Background = new CompositionEffectSourceParameter("Background"),
                    Foreground = new CompositionEffectSourceParameter("Foreground")
                };
                m_blendEffectBrushes[i] = m_compositor.CreateEffectFactory(
                    blendEffectDesc
                ).CreateBrush();
                m_blendEffectBrushes[i].SetSourceParameter(
                    "Background",
                    m_noEffectBrush);
                m_blendEffectBrushes[i].SetSourceParameter(
                    "Foreground",
                    foregroundBrush);
            }

            // Generates an image containing a solid color.
            var colorSourceEffectDesc = new ColorSourceEffect // FloodEffect
            {
                Name = "effect"
            };
            m_colorSourceEffectBrush = m_compositor.CreateEffectFactory(
                colorSourceEffectDesc,
                new[] { "effect.Color" }
            ).CreateBrush();

            // Changes the contrast of an image.
            var contrastEffectDesc = new ContrastEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_contrastEffectBrush = m_compositor.CreateEffectFactory(
                contrastEffectDesc,
                new[] { "effect.Contrast" }
            ).CreateBrush();
            m_contrastEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Changes the exposure of an image.
            var exposureEffectDesc = new ExposureEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_exposureEffectBrush = m_compositor.CreateEffectFactory(
                exposureEffectDesc,
                new[] { "effect.Exposure" }
            ).CreateBrush();
            m_exposureEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Alters the colors of an image by applying a per-channel gamma transfer function.
            var gammaTransferEffectDesc = new GammaTransferEffect
            {
                Name = "effect",
                RedDisable = false,
                GreenDisable = false,
                BlueDisable = false,
                AlphaDisable = false,
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_gammaTransferEffectBrush = m_compositor.CreateEffectFactory(
                gammaTransferEffectDesc,
                new[]
                {
                    "effect.RedAmplitude",
                    "effect.RedExponent",
                    "effect.RedOffset",
                    "effect.GreenAmplitude",
                    "effect.GreenExponent",
                    "effect.GreenOffset",
                    "effect.BlueAmplitude",
                    "effect.BlueExponent",
                    "effect.BlueOffset"
                }
            ).CreateBrush();
            m_gammaTransferEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Converts an image to monochromatic gray.
            var grayscaleEffectDesc = new GrayscaleEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_grayscaleEffectBrush = m_compositor.CreateEffectFactory(
                grayscaleEffectDesc
            ).CreateBrush();
            m_grayscaleEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Alters the color of an image by rotating its hue values.
            var hueRotationEffectDesc = new HueRotationEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_hueRotationEffectBrush = m_compositor.CreateEffectFactory(
                hueRotationEffectDesc,
                new[] { "effect.Angle" }
            ).CreateBrush();
            m_hueRotationEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Inverts the colors of an image.
            var invertEffectDesc = new InvertEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_invertEffectBrush = m_compositor.CreateEffectFactory(
                invertEffectDesc
            ).CreateBrush();
            m_invertEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Alters the saturation of an image.
            var saturationEffectDesc = new SaturationEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_saturateEffectBrush = m_compositor.CreateEffectFactory(
                saturationEffectDesc,
                new[] { "effect.Saturation" }
            ).CreateBrush();
            m_saturateEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Converts an image to sepia tones.
            var supportedAlphaModes = new[]
            {
                CanvasAlphaMode.Premultiplied,
                CanvasAlphaMode.Straight
            };
            m_sepiaEffectBrushes = new CompositionEffectBrush[supportedAlphaModes.Length];
            for (int i = 0; i < supportedAlphaModes.Length; i++)
            {
                var sepiaEffectDesc = new SepiaEffect
                {
                    Name = "effect",
                    AlphaMode = supportedAlphaModes[i],
                    Source = new CompositionEffectSourceParameter("Image")
                };
                m_sepiaEffectBrushes[i] = m_compositor.CreateEffectFactory(
                    sepiaEffectDesc,
                    new[] { "effect.Intensity" }
                ).CreateBrush();
                m_sepiaEffectBrushes[i].SetSourceParameter(
                    "Image",
                    m_noEffectBrush);
            }

            // Adjusts the temperature and/or tint of an image.
            var temperatureAndTintEffectDesc = new TemperatureAndTintEffect
            {
                Name = "effect",
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_temperatureAndTintEffectBrush = m_compositor.CreateEffectFactory(
                temperatureAndTintEffectDesc,
                new[]
                {
                    "effect.Temperature",
                    "effect.Tint"
                }
            ).CreateBrush();
            m_temperatureAndTintEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // Applies a 2D affine transform matrix to an image.
            var transform2DEffectDesc = new Transform2DEffect
            {
                TransformMatrix = new Matrix3x2(
                    -1, 0,
                    0, 1,
                    m_sprite.Size.X, 0),
                Source = new CompositionEffectSourceParameter("Image")
            };
            m_transform2DEffectBrush = m_compositor.CreateEffectFactory(
                transform2DEffectDesc
            ).CreateBrush();
            m_transform2DEffectBrush.SetSourceParameter(
                "Image",
                m_noEffectBrush);

            // For simplying UI states switch, put effect parameter grids in an array
            m_effectParamsGrids = new Grid[(int)EffectType.NumEffectTypes];
            m_effectParamsGrids[(int)EffectType.NoEffect] = null;
            m_effectParamsGrids[(int)EffectType.AlphaMask] = AlphaMaskParams;
            m_effectParamsGrids[(int)EffectType.Arithmetic] = ArithmeticParams;
            m_effectParamsGrids[(int)EffectType.Blend] = BlendParams;
            m_effectParamsGrids[(int)EffectType.ColorSource] = ColorSourceParams;
            m_effectParamsGrids[(int)EffectType.Contrast] = ContrastParams;
            m_effectParamsGrids[(int)EffectType.Exposure] = ExposureParams;
            m_effectParamsGrids[(int)EffectType.GammaTransfer] = GammaTransferParams;
            m_effectParamsGrids[(int)EffectType.Grayscale] = null;
            m_effectParamsGrids[(int)EffectType.HueRotation] = HueRotationParams;
            m_effectParamsGrids[(int)EffectType.Invert] = null;
            m_effectParamsGrids[(int)EffectType.Saturation] = SaturationParams;
            m_effectParamsGrids[(int)EffectType.Sepia] = SepiaParams;
            m_effectParamsGrids[(int)EffectType.TemperatureAndTint] = TemperatureAndTintParams;
            m_effectParamsGrids[(int)EffectType.Transform2D] = null;

            // Same as grids
            m_effectBrushes = new CompositionBrush[(int)EffectType.NumEffectTypes];
            m_effectBrushes[(int)EffectType.NoEffect] = m_noEffectBrush;
            m_effectBrushes[(int)EffectType.AlphaMask] = m_alphaMaskEffectBrush;
            m_effectBrushes[(int)EffectType.Arithmetic] = m_arithmeticEffectBrush;
            m_effectBrushes[(int)EffectType.Blend] = m_blendEffectBrushes[m_activeBlendMode];
            m_effectBrushes[(int)EffectType.ColorSource] = m_colorSourceEffectBrush;
            m_effectBrushes[(int)EffectType.Contrast] = m_contrastEffectBrush;
            m_effectBrushes[(int)EffectType.Exposure] = m_exposureEffectBrush;
            m_effectBrushes[(int)EffectType.GammaTransfer] = m_gammaTransferEffectBrush;
            m_effectBrushes[(int)EffectType.Grayscale] = m_grayscaleEffectBrush;
            m_effectBrushes[(int)EffectType.HueRotation] = m_hueRotationEffectBrush;
            m_effectBrushes[(int)EffectType.Invert] = m_invertEffectBrush;
            m_effectBrushes[(int)EffectType.Saturation] = m_saturateEffectBrush;
            m_effectBrushes[(int)EffectType.Sepia] = m_sepiaEffectBrushes[m_activeSepiaAlphaMode];
            m_effectBrushes[(int)EffectType.TemperatureAndTint] = m_temperatureAndTintEffectBrush;
            m_effectBrushes[(int)EffectType.Transform2D] = m_transform2DEffectBrush;

            this.InitializeValues();
        }