XNA for C#
DirectX 9 for C#
DirectX 9 for C++
DirectX 9 for VB
Forum
   
My XNA Book
      
       Go to section on this site

Additional info


Latest Forum posts

 Account settings
  Posted by: Anonymous
  When: 07/05/2014 at 09:48:39

 forced subtitle
  Posted by: Applefly
  When: 07/05/2014 at 06:00:48

 convert DVD into PMS
  Posted by: Applefly
  When: 07/05/2014 at 05:55:25

 DVD to Digital Copy easily
  Posted by: VIKIVannessa
  When: 05/05/2014 at 06:52:29

 DVD on Xbox 360/Xbox One Console
  Posted by: VIKIVannessa
  When: 05/05/2014 at 06:51:47

 Extract .Srt Subtitles
  Posted by: Applefly
  When: 04/05/2014 at 03:54:38

 Encode Movie collection
  Posted by: Applefly
  When: 04/05/2014 at 03:52:41

 Convert DVD to WMV
  Posted by: Applefly
  When: 29/04/2014 at 05:53:50

 rip DVDs into digital files
  Posted by: Applefly
  When: 29/04/2014 at 05:51:20

 iTunes movies/music to Kindle Fire
  Posted by: ciciyu80
  When: 29/04/2014 at 05:10:20


Ads

Handling Lost Devices – Solving the Resizing problem

Because this question is asked many times on the forum, I’ve decided to dedicate a small page to it. Maybe you think the contents of this page should have been included into the standard tutorials, but it handles a lot of memory management issues that you would NOT like to meet on your first DirectX day.

The DirectX resources are all connected to the device, which again is connected to its host, the form (or the screen, when talking about a fullscreen app). Whenever anything happens to this host (resizing, change of resolution), it is only logical that a lot of the DirectX resources have to be redeclared. Such resources include images linked to your device, index and vertex buffers, but also camera matrices and render states.

Whenever the user resizes the form, the device will become ‘lost’. This means that all the resources will be discarded. When the app regains focus (eg. Immediately after the resizing action) the device will be reset.

Then again, there is a big difference between resources that have been created In the Default memory, and others that reside in the Managed memory pool. Of all the resources in the Managed memory pool, DirectX keeps a copy in the main system memory (=RAM), so DirectX will be able to reallocate memory for the Managed resources. However, the contents will be LOST. So the difference between managed and default resources is that default resources have to be reallocated and filled by the user, where managed resources only have to be filled by the user.

Let’s have a look at our page on ‘Terrain Creation’, as we use both index and vertex buffers in that case. We’re simply going to hook the Reset Event to a new function. To do this, add this line immediately after your device creation:

 device.DeviceReset += new EventHandler(HandleResetEvent);

So whenever the device is reset, our HandleResetEvent method is fired. In this method, we’re simply going to make sure all our resources are refilled:

 private void HandleResetEvent(object caller, EventArgs args)
 {
  device.RenderState.FillMode = FillMode.WireFrame;
  device.RenderState.CullMode = Cull.None;
  CameraPositioning();
  VertexDeclaration();
  IndicesDeclaration();
 }

As you see, the renderstates, camera matrices and buffers are restored. This should already do the trick. The rest of this page will cover some more details.

When you have a look at the CameraPositioning method, you’ll that the resolution of the form is passed to DirectX by using this.Width and this.Height:

 device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, (float)(this.Width / this.Height), 1f, 50f);

So when the window is resized, our application will automatically use the correct aspect ratio!

Next I should give some more detail about the buffers. As you can see, I have created our buffers in the Default memory pool. When you have a look at the first line of the VertexDeclaration method, you’ll see I re-create the buffer each time the device is reset. This is needed, because we’re using the Default memory pool.

In the case we had created our buffer using the Managed memory pool, we would only have had to create this buffer once, because on device reset it would automatically be created by DirectX. Remember you still would have to refill it with data.



Click here to go to the forum on this chapter!

Or click on one of the topics on this chapter to go there:
  • Black geometry after resize
          I used the DeviceLost event in my project exactly ...
  • Not 100% reliable when shrinking window
          The code presented in this section works fine when...


    If you have any questions on this text, feel free to post them in the forum. Here you can find the code integrated into our tutorial:

     using System;
     using System.Drawing;
     using System.Collections;
     using System.ComponentModel;
     using System.Windows.Forms;
     using System.Data;
     using Microsoft.DirectX;
     using Microsoft.DirectX.Direct3D;
     
     namespace DirectX_Tutorial
     {
     
         public class WinForm : System.Windows.Forms.Form
         {
             private int WIDTH = 4;
             private int HEIGHT = 3;
             private Device device;
             private System.ComponentModel.Container components = null;
             private float angle = 0f;
             private CustomVertex.PositionColored[] vertices;
             private int[,] heightData;
             private int[] indices;
             private IndexBuffer ib;
             private VertexBuffer vb;
     
     
             public WinForm()
             {
                 InitializeComponent();
                 this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
             }
     
             public void InitializeDevice()
             {
                 PresentParameters presentParams = new PresentParameters();
                 presentParams.Windowed = true;
                 presentParams.SwapEffect = SwapEffect.Discard;
                 device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
                 device.RenderState.FillMode = FillMode.WireFrame;
                 device.RenderState.CullMode = Cull.None;
     
                 device.DeviceReset += new EventHandler(HandleResetEvent);
             }
     
             private void HandleResetEvent(object caller, EventArgs args)
             {
                 device.RenderState.FillMode = FillMode.WireFrame;
                 device.RenderState.CullMode = Cull.None;
                 CameraPositioning();
                 VertexDeclaration();
                 IndicesDeclaration();
             }
     
             private void CameraPositioning()
             {
                 device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, (float)(this.Width / this.Height), 1f, 50f);
                 device.Transform.View = Matrix.LookAtLH(new Vector3(0, 0, 15), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
                 device.RenderState.Lighting = false;
                 device.RenderState.CullMode = Cull.None;
             }
     
             private void VertexDeclaration()
             {
                 vb = new VertexBuffer(typeof(CustomVertex.PositionColored), WIDTH * HEIGHT, device, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
                 vertices = new CustomVertex.PositionColored[WIDTH * HEIGHT];
                 for (int x = 0; x < WIDTH; x++)
                 {
                     for (int y = 0; y < HEIGHT; y++)
                     {
                         vertices[x + y * WIDTH].Position = new Vector3(x, y, heightData[x, y]);
                         vertices[x + y * WIDTH].Color = Color.White.ToArgb();
                     }
                 }
     
                 vb.SetData(vertices, 0, LockFlags.None);
             }
     
             private void IndicesDeclaration()
             {
                 ib = new IndexBuffer(typeof(int), (WIDTH - 1) * (HEIGHT - 1) * 6, device, Usage.WriteOnly, Pool.Default);
                 indices = new int[(WIDTH - 1) * (HEIGHT - 1) * 6];
                 for (int x = 0; x < WIDTH - 1; x++)
                 {
                     for (int y = 0; y < HEIGHT - 1; y++)
                     {
                         indices[(x + y * (WIDTH - 1)) * 6] = (x + 1) + (y + 1) * WIDTH;
                         indices[(x + y * (WIDTH - 1)) * 6 + 1] = (x + 1) + y * WIDTH;
                         indices[(x + y * (WIDTH - 1)) * 6 + 2] = x + y * WIDTH;
     
                         indices[(x + y * (WIDTH - 1)) * 6 + 3] = (x + 1) + (y + 1) * WIDTH;
                         indices[(x + y * (WIDTH - 1)) * 6 + 4] = x + y * WIDTH;
                         indices[(x + y * (WIDTH - 1)) * 6 + 5] = x + (y + 1) * WIDTH;
                     }
                 }
                 ib.SetData(indices, 0, LockFlags.None);
             }
     
     
             protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
             {
                 device.Clear(ClearFlags.Target, Color.DarkSlateBlue, 1.0f, 0);
     
                 device.BeginScene();
                 device.VertexFormat = CustomVertex.PositionColored.Format;
                 device.SetStreamSource(0, vb, 0);
                 device.Indices = ib;
     
                 device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, WIDTH * HEIGHT, 0, indices.Length / 3);
                 device.EndScene();
     
                 device.Present();
     
                 this.Invalidate();
                 angle += 0.05f;
             }
     
             private void LoadHeightData()
             {
                 heightData = new int[4, 3];
     
                 heightData[0, 0] = 0;
                 heightData[1, 0] = 0;
                 heightData[2, 0] = 0;
                 heightData[3, 0] = 0;
     
                 heightData[0, 1] = 1;
                 heightData[1, 1] = 0;
                 heightData[2, 1] = 2;
                 heightData[3, 1] = 2;
     
                 heightData[0, 2] = 2;
                 heightData[1, 2] = 2;
                 heightData[2, 2] = 4;
                 heightData[3, 2] = 2;
             }
     
             protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
                     if (components != null)
                     {
                         components.Dispose();
                     }
                 }
                 base.Dispose(disposing);
             }
     
             private void InitializeComponent()
             {
                 this.components = new System.ComponentModel.Container();
                 this.Size = new System.Drawing.Size(500, 500);
                 this.Text = "DirectX Tutorial";
             }
     
             static void Main()
             {
                 using (WinForm our_directx_form = new WinForm())
                 {
                     our_directx_form.LoadHeightData();
                     our_directx_form.InitializeDevice();
                     our_directx_form.CameraPositioning();
                     our_directx_form.VertexDeclaration();
                     our_directx_form.IndicesDeclaration();
                     Application.Run(our_directx_form);
                 }
             }
         }
     }
     


    Google
     
    Webwww.riemers.net


    If you appreciate the amount of time I spend creating and updating
    these pages, feel free to donate -- any amount is welcome !



    - Website design & XNA + DirectX code : Riemer Grootjans -
    ©2003 - 2011 Riemer Grootjans
  • Translations

    This site in English
    This site in Korean
    This site in Czech

    Microsoft MVP Award



    2007 - 2011 MVP Award
    DirectX - XNA

    Contents

    News
    Home
    Forum
    XNA 2.0 Recipes Book (8)
    XNA 3.0 Recipes Book (8)
    Downloads
    Extra Reading (3)
    Matrices: geometrical
    Matrix Mathematics
    Homogenous matrices
    Community Projects (1)
    Tutorials (160)
    XNA 4.0 using C# (89)
    DirectX using C# (54)
    Series 1:Terrain (14)
    Series 2: Flightsim (19)
    Series 3: HLSL (19)
    Short Tuts (2)
    Resizing problem
    Checking Device caps
    DirectX using C++ (15)
    DirectX using VB (2)
    -- Expand all --


    Thank you!

    Support this site --
    any amount is welcome !

    Stay up-to-date

    I don't have the time to keep a News section, so stay informed about the updates by clicking on this RSS file!