Question

I’m trying to handle the program window being resized, and the (I think inefficient) code I’ve flung together below seems to do the trick.

Is there a better way to do this, preferably one that does not create a stutter when resizing the window and which does not constantly use 12-17% of a CPU? I also suspect MessagePump.Run may somehow run before form.Resize finishes setting up the device again, and throw an error.

Thanks!

using System;
using System.Drawing;
using System.Windows.Forms;

using SlimDX;
using SlimDX.Direct3D9;
using SlimDX.Windows;

namespace SlimDX_1
{
    struct Vertex
    {
        public Vector4 Position;
        public int Color;
    }

    static class Program
    {
        private static VertexBuffer vertices;
        private static Device device;
        private static RenderForm form;
        private static PresentParameters present;
        private static VertexDeclaration vertexDecl;
        private static VertexElement[] vertexElems;

        private static bool wasMinimized = false;

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            form = new RenderForm("Tutorial 1: Basic Window");

            init();

            form.Resize += (o, e) =>
                {
                    if (form.WindowState == FormWindowState.Minimized)
                    {
                        foreach (var item in ObjectTable.Objects)
                        {
                            item.Dispose();
                        }
                        wasMinimized = true;
                    }
                    else
                    {
                        foreach (var item in ObjectTable.Objects)
                        {
                            item.Dispose();
                        }
                        init();

                        device.SetRenderState(RenderState.FillMode, FillMode.Wireframe);
                        device.SetRenderState(RenderState.CullMode, Cull.None);

                        present.BackBufferHeight = form.ClientSize.Height;
                        present.BackBufferWidth = form.ClientSize.Width;

                        device.Reset(present);
                    }
                };

            MessagePump.Run(form, () =>
            {
                if (form.WindowState == FormWindowState.Minimized)
                {
                    return;
                }

                device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
                device.BeginScene();

                device.SetStreamSource(0, vertices, 0, 20); // 20 is the size of each vertex
                device.VertexDeclaration = vertexDecl;
                device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);

                device.EndScene();
                device.Present();
            });

            foreach (var item in ObjectTable.Objects)
            {
                item.Dispose();
            }
        }

        private static void init()
        {
            present = new PresentParameters();
            //present.EnableAutoDepthStencil = false;
            //present.BackBufferCount = 1;
            //present.SwapEffect = SwapEffect.Discard;
            present.Windowed = true;
            present.BackBufferHeight = form.ClientSize.Height;
            present.BackBufferWidth = form.ClientSize.Width;
            //present.BackBufferFormat = Format.Unknown;

            device = new Device(new Direct3D(), 0, DeviceType.Hardware, form.Handle, CreateFlags.HardwareVertexProcessing, present);

            vertices = new VertexBuffer(device, 3 * 20, Usage.WriteOnly, VertexFormat.None, Pool.Managed);
            vertices.Lock(0, 0, LockFlags.None).WriteRange(new Vertex[]
            {
                new Vertex() { Color = Color.Red.ToArgb(), Position = new Vector4(400.0f, 100.0f, 0.5f, 1.0f) },
                new Vertex() { Color = Color.Blue.ToArgb(), Position = new Vector4(650.0f, 500.0f, 0.5f, 1.0f) },
                new Vertex() { Color = Color.Green.ToArgb(), Position = new Vector4(150.0f, 500.0f, 0.5f, 1.0f) }
            });
            vertices.Unlock();

            // specifies the layout of the vertexes
            vertexElems = new VertexElement[]
            {
                new VertexElement(0, 0, DeclarationType.Float4, DeclarationMethod.Default, DeclarationUsage.PositionTransformed, 0),
                new VertexElement(0, 16, DeclarationType.Color, DeclarationMethod.Default, DeclarationUsage.Color, 0),
                VertexElement.VertexDeclarationEnd
            };

            vertexDecl = new VertexDeclaration(device, vertexElems);
        }
    }
}

Answer 1

You’re going way above and beyond what you need to do when the window is resized. You’re releasing every single DirectX object you’ve created, including the graphics device, and then recreating everything. This is going to take a comparatively long time, which is why you’re seeing performance issues.

In fact, none of your objects need to be released. Simply call the Reset() function on the device to recreate the backbuffer to match the new window size. Check out some of the native Direct3D9 tutorials on window resizing to see how in general how the process works.