Crash during resize of UserControl with embedded RenderWindow

[Conduit]

I'm creating a UserControl for use in a WinForms application which embeds and displays a RenderWindow using the method suggested in this forum post. Everything works well so far except when the control is resized. When the control is resized I want to recreate the embedded RenderWindow with a VideoMode that won't result in stretching, but this often results in the program crashing with no exceptions thrown... VS2013 gives me nothing to work with but a "vshost.exe has stopped working" message. I'm at a complete loss - any ideas for troubleshooting or fixing this are very, very welcome. The pertinent code is below.

(click to show/hide)

using SFML.Graphics;
using SFML.System;
using System;
using System.Windows.Forms;

namespace RenderControl
{
    public partial class Form1 : Form
    {
        RenderControl m_RenderControl = new RenderControl();
        RectangleShape m_Square = new RectangleShape(new Vector2f(20f, 20f));

        public Form1()
        {
            InitializeComponent();
            this.splitContainer1.Panel1.Controls.Add(this.m_RenderControl);
            this.m_RenderControl.Size = this.splitContainer1.Panel1.ClientSize;
            this.m_RenderControl.Create();

            this.m_Square.OutlineColor = Color.Transparent;
            this.m_Square.FillColor = Color.White;

            this.timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            this.m_RenderControl.DispatchEvents();
            this.m_RenderControl.Clear();
            this.m_RenderControl.Draw(this.m_Square);
            this.m_RenderControl.Display();
        }

        private void splitContainer1_SplitterMoved(object sender, SplitterEventArgs e)
        {
            this.m_RenderControl.Size = this.splitContainer1.Panel1.ClientSize;
        }
    }
}
 

(click to show/hide)

namespace RenderControl
{
    partial class Form1
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this.splitContainer1 = new System.Windows.Forms.SplitContainer();
            this.timer1 = new System.Windows.Forms.Timer(this.components);
            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
            this.splitContainer1.SuspendLayout();
            this.SuspendLayout();
            //
            // splitContainer1
            //
            this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
            this.splitContainer1.Location = new System.Drawing.Point(0, 0);
            this.splitContainer1.Name = "splitContainer1";
            this.splitContainer1.Size = new System.Drawing.Size(284, 262);
            this.splitContainer1.SplitterDistance = 202;
            this.splitContainer1.TabIndex = 0;
            this.splitContainer1.SplitterMoved += new System.Windows.Forms.SplitterEventHandler(this.splitContainer1_SplitterMoved);
            //
            // timer1
            //
            this.timer1.Interval = 250;
            this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(284, 262);
            this.Controls.Add(this.splitContainer1);
            this.Name = "Form1";
            this.Text = "Form1";
            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
            this.splitContainer1.ResumeLayout(false);
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.SplitContainer splitContainer1;
        private System.Windows.Forms.Timer timer1;
    }
}

 

(click to show/hide)

using SFML.Graphics;
using SFML.Window;
using System;
using System.Threading;
using System.Windows.Forms;

namespace RenderControl
{
    public partial class RenderControl : UserControl
    {
        private RenderWindow m_Window = null;
        private uint m_Depth = 0;
        private uint m_Stencil = 0;
        private uint m_Antialiasing = 0;
        private uint m_Major = 2;
        private uint m_Minor = 0;

        public RenderControl(uint depth = 0, uint stencil = 0, uint antialiasing = 0, uint major = 2, uint minor = 0)
        {
            InitializeComponent();
            this.SizeChanged += new EventHandler(RenderControl_SizeChanged);

            this.m_Depth = depth;
            this.m_Stencil = stencil;
            this.m_Antialiasing = antialiasing;
            this.m_Major = major;
            this.m_Minor = minor;
        }
        ~RenderControl()
        {
            this.m_Window.Dispose();
        }

        #region interface

        public void Create()
        {
            Monitor.Enter(this);

            this.m_Window = new RenderWindow(this.Handle, new ContextSettings(this.m_Depth, this.m_Stencil, this.m_Antialiasing
                                                                            , this.m_Major, this.m_Minor));
            this.m_Window.SetVerticalSyncEnabled(true);

            Monitor.Exit(this);
        }
        public void Destroy()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
            {
                this.m_Window.Close();
                this.m_Window.Dispose();
                this.m_Window = null;
            }

            Monitor.Exit(this);
        }

        public void DispatchEvents()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.DispatchEvents();

            Monitor.Exit(this);
        }

        public void SetActive(bool active = true)
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
                this.m_Window.SetActive(active);

            Monitor.Exit(this);
        }

        public void Clear()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(Color.Black);

            Monitor.Exit(this);
        }
        public void Clear(Color color)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(color);

            Monitor.Exit(this);
        }

        public void Draw(Drawable drawable)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable);

            Monitor.Exit(this);
        }
        public void Draw(Drawable drawable, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type, states);

            Monitor.Exit(this);
        }

        public void Display()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Display();

            this.Refresh();

            Monitor.Exit(this);
        }

        #endregion

        #region paint overrides
        protected override void OnPaint(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaint(e);
        }
        protected override void OnPaintBackground(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaintBackground(e);
        }
        #endregion

        void RenderControl_SizeChanged(object sender, EventArgs e)
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
            {
                this.Create();
            }

            Monitor.Exit(this);
        }
    }
}
 

[zsbzsb]

I want to recreate the embedded RenderWindow with a VideoMode that won't result in stretching

Why don't you resize the view like you are supposed to do?

http://www.sfml-dev.org/tutorials/2.2/graphics-view.php#showing-more-when-the-window-is-resized

Recreating the window every time the control's size changes 1 pixel is not the way to do it and will make your application extremely slow. Not to mention SFML doesn't exactly play nicely with threads in some situations, so I don't understand why you have all these monitor calls all over. It is also well established multithreading your drawing calls won't help anything (OpenGL is single threaded).

this.m_Window = new RenderWindow(this.Handle, new ContextSettings(this.m_Depth, this.m_Stencil, this.m_Antialiasing, this.m_Major, this.m_Minor));

You never dispose the old window, which causes your memory usage to go through the roof considering you do this every time the size changes. Either way, you shouldn't recreate it as I said before, learn to do it right with the view.

private uint m_Depth = 0;
private uint m_Stencil = 0;
private uint m_Antialiasing = 0;
private uint m_Major = 2;
private uint m_Minor = 0;

Why don't you just store a context setting struct as a member variable?

[Conduit]

Thanks for the tips!

Why don't you resize the view like you are supposed to do?

I don't know how I missed that section of the View tutorial, but that would probably do the trick. Ideally the RenderControl would work when its DockStyle was set to fill, but that caused a lot of trouble initially... I'll give this a try and report back.

You never dispose the old window

Good catch. Ran into trouble when testing before I'd finished the class, and must have missed that.

Not to mention SFML doesn't exactly play nicely with threads in some situations, so I don't understand why you have all these monitor calls all over

This control will eventually be incorporated into an application where rendering runs in a separate thread than the GUI, as is necessary to keep the GUI from hanging when using a rendering loop. After I shifted construction of all OpenGL-related objects to the rendering thread I haven't had any trouble when using SFML in my multithreaded app... if you have/know of any specific concerns, I'd be happy to hear them, though!

As for their purpose: if the GUI thread calls Destroy/Create at the same time the rendering thread calls Draw (or something) then we might have a race - if m_Window.Dispose had been called but m_Window hadn't yet been set to null, for example, we might try to draw to the disposed object (right...?). These will probably be converted into something more elegant, but during testing they will stay there.

Why don't you just store a context setting struct as a member variable

I had been considering making these changeable, but then I noticed that SFML doesn't let you do this and figured I shouldn't either. In retrospect I don't really know why you'd want to change them anyway. That will be fixed as soon as the more important bits are taken care of.



EDIT: Altering the view as suggested in that tutorial works wonderfully - thanks for the link.
At this point, zsbzsb, I practically owe you a co-author credit on my application

As it stands I believe the class to be fully functional - if there are other concerns to be considered in a multithreaded application, though, I might need to make some changes (e.g. I am not entirely sure which of the built-in RenderWindow functions won't lead to a race, so some uses of Monitor might be unnecessary). I might just do away with the Monitor stuff entirely and assume that it will be handled externally (if needed), as this is more in line with what is expected of SFML.

Feel free to toss any other suggestions my way - revised code below.

(click to show/hide)

using SFML.Graphics;
using SFML.Window;
using System;
using System.Threading;
using System.Windows.Forms;

namespace RenderControl
{
    public partial class RenderControl : UserControl
    {
        private RenderWindow m_Window = null;
        private ContextSettings m_Context;

        public RenderControl(uint depth = 0, uint stencil = 0, uint antialiasing = 0, uint major = 2, uint minor = 0)
        {
            InitializeComponent();

            this.m_Context = new ContextSettings(depth, stencil, antialiasing, major, minor);
            this.SizeChanged += new EventHandler(RenderControl_SizeChanged);
        }
        ~RenderControl()
        {
            this.m_Window.Dispose();
        }

        #region interface

        public void Create()
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
                this.m_Window.Dispose();
            this.m_Window = new RenderWindow(this.Handle, this.m_Context);
            this.m_Window.SetVerticalSyncEnabled(true);

            Monitor.Exit(this);
        }
        public void Destroy()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
            {
                this.m_Window.Close();
                this.m_Window.Dispose();
                this.m_Window = null;
            }

            Monitor.Exit(this);
        }

        public void DispatchEvents()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.DispatchEvents();

            Monitor.Exit(this);
        }

        public void SetActive(bool active = true)
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
                this.m_Window.SetActive(active);

            Monitor.Exit(this);
        }

        public void Clear()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(Color.Black);

            Monitor.Exit(this);
        }
        public void Clear(Color color)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(color);

            Monitor.Exit(this);
        }

        public void Draw(Drawable drawable)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable);

            Monitor.Exit(this);
        }
        public void Draw(Drawable drawable, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type, states);

            Monitor.Exit(this);
        }

        public void Display()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Display();

            this.Refresh();

            Monitor.Exit(this);
        }

        #endregion

        #region paint overrides
        protected override void OnPaint(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaint(e);
        }
        protected override void OnPaintBackground(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaintBackground(e);
        }
        #endregion

        void RenderControl_SizeChanged(object sender, EventArgs e)
        {
            Monitor.Enter(this);

            //need to recreate view when the window changes
            if(this.m_Window != null)
            {
                this.m_Window.SetView(new SFML.Graphics.View(new FloatRect(0f, 0f, this.Size.Width, this.Size.Height)));
            }

            Monitor.Exit(this);
        }
    }
}