public override void OnPreviewSettings()
    {
        _renderMode = (RenderMode)EditorGUILayout.EnumPopup(_renderMode);

        if (_viewPreview != null)
        {
            View.RenderFlags flags = DeviceIsD3D() ? View.RenderFlags.FlipY : 0;

            if (_renderMode == RenderMode.Normal)
            {
                _viewPreview.SetFlags(flags);
            }
            else if (_renderMode == RenderMode.Wireframe)
            {
                _viewPreview.SetFlags(flags | View.RenderFlags.Wireframe);
            }
            else if (_renderMode == RenderMode.Batches)
            {
                _viewPreview.SetFlags(flags | View.RenderFlags.ColorBatches);
            }
            else if (_renderMode == RenderMode.Overdraw)
            {
                _viewPreview.SetFlags(flags | View.RenderFlags.Overdraw);
            }
        }
    }
    private void CreatePreviewGUIView()
    {
        try
        {
            NoesisXaml       xaml  = (NoesisXaml)target;
            FrameworkElement root  = xaml.Load() as FrameworkElement;
            View.RenderFlags flags = DeviceIsD3D() ? View.RenderFlags.FlipY : 0;

            if (root != null)
            {
                _viewPreviewGUI = Noesis.GUI.CreateView(root);
                _viewPreviewGUI.SetFlags(flags);
                NoesisRenderer.RegisterView(_viewPreviewGUI);
            }
        }
        catch (System.Exception e)
        {
            UnityEngine.Debug.LogException(e);
        }
    }
        /// <summary>
        /// Create the panel.
        /// </summary>
        private void CreatePanel()
        {
            if (!this.noesisService.StyleValid)
            {
                return;
            }

            this.viewSettingsDirty = false;

            this.totalTime = TimeSpan.Zero;

            try
            {
                if (!string.IsNullOrEmpty(this.Xaml))
                {
                    object root = Noesis.GUI.LoadXaml(this.Xaml);

                    if (root == null)
                    {
                        throw new Exception($"Unable to load XAML {this.Xaml}");
                    }

                    if (!(root is FrameworkElement))
                    {
                        throw new Exception($"{this.Xaml} is not a FrameworkElement");
                    }

                    this.view = Noesis.GUI.CreateView((FrameworkElement)root);

                    if (!this.IsRenderToTexture)
                    {
                        var vsm = this.Owner.Scene.VirtualScreenManager.VirtualScreenRectangle;

                        this.width  = (int)vsm.Width;
                        this.height = (int)vsm.Height;
                    }

                    if (this.width <= 0)
                    {
                        throw new Exception("Panel width must be positive");
                    }

                    if (this.height <= 0)
                    {
                        throw new Exception("Panel height must be positive");
                    }

                    this.view.SetSize(this.width, this.height);
                    this.view.SetIsPPAAEnabled(this.antiAliasingMode == View.AntialiasingMode.PPAA);
                    this.view.SetTessellationQuality(this.tessellationQuality);

                    // In OpenGL platforms, enable FlipY when the component is rendering to texture
                    View.RenderFlags renderFlags = this.renderFlags;
                    bool             doFlip      = (WaveServices.Platform.AdapterType != AdapterType.DirectX && this.IsRenderToTexture) ^ this.flipY;
                    renderFlags |= doFlip ? (View.RenderFlags)View.HiddenRenderFlags.FlipY : 0;
                    this.view.SetFlags(renderFlags);

                    this.renderer = this.view.Renderer;

                    this.NoesisBegin(false);
                    this.renderer.Init(this.noesisService.RenderDevice);
                    this.NoesisEnd();

                    this.view.Update(0);

                    if (!this.IsRenderToTexture)
                    {
                        this.camera.OnPreRender += this.Noesis_OnCameraPreRender;
                        this.EnablePostProcess   = this.enablePostProcess;
                    }
                    else
                    {
                        this.RenderManager.OnPreRender += this.Noesis_RenderToTexture;
                        this.transform      = this.Owner.FindComponent <Transform3D>(false);
                        this.screenViewport = new Viewport(0, 0, this.width, this.height);
                        this.renderTarget   = this.graphicsDevice.RenderTargets.CreateRenderTarget(this.width, this.height);

                        // Try to set the texture to the material.
                        this.SetPanelMaterialTexture(this.Texture);
                    }

                    this.OnViewCreated?.Invoke(this, this.view);
                }
            }
            catch (Exception e)
            {
                // This usually happens when loading a XAML with undefined resources or with an incorrect root type
                NoesisErrorConsole.PrintPanelError(this.Owner.Name, e);

                // Set default texture
                this.SetPanelMaterialTexture(StaticResources.DefaultTexture);
            }
        }