using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Windows.Interop;

using System.Drawing;

using SlimDX;
using SlimDX.Direct3D9;

namespace D3DIMageTest
{
	/// <summary>
	/// Interaction logic for Window1.xaml
	/// </summary>
	public partial class Window1 : Window
	{
		SlimDX.Direct3D9.Direct3D direct3D = new SlimDX.Direct3D9.Direct3D();
		Device device;  
		Sprite sprite;  
		Texture texture;  

		public Window1()
		{
			InitializeComponent();
			Loaded += new RoutedEventHandler(Window_Loaded);
		}
		
		private void Window_Loaded(object sender, RoutedEventArgs e)  
		{  
			InitializeD3D();  
			CompositionTarget.Rendering += OnRendering;  
			d3dimage.IsFrontBufferAvailableChanged += new DependencyPropertyChangedEventHandler(OnIsFrontBufferAvailableChanged);
			
			d3dimage.Lock();  
			d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, device.GetBackBuffer(0, 0).ComPointer);  
			d3dimage.Unlock();  
		}

		
		public void InitializeD3D()  
		{  
			HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "test", IntPtr.Zero);  
			
			PresentParameters pp = new PresentParameters();  
			pp.SwapEffect = SwapEffect.Discard;  
			pp.DeviceWindowHandle = hwnd.Handle;  
			pp.Windowed = true;  
			pp.BackBufferWidth = 400;  
			pp.BackBufferHeight = 400;  
			pp.BackBufferFormat = Format.X8R8G8B8;  
			
			device = new Device(direct3D, 0, 
			                    DeviceType.Hardware, 
			                    hwnd.Handle, 
			                    CreateFlags.HardwareVertexProcessing, 
			                    pp);
			
		}
		
		
		private void OnRendering(object sender, EventArgs e)
		{
			try {
				d3dimage.Lock(); 
				d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, device.GetBackBuffer(0, 0).ComPointer);  
				RenderD3D();
				d3dimage.AddDirtyRect(new Int32Rect(0, 0, d3dimage.PixelWidth, d3dimage.PixelHeight));
				d3dimage.Unlock();
			}
			catch (Direct3D9Exception ex) {
				string msg = ex.Message;
			}
		}
		
		void OnIsFrontBufferAvailableChanged(object sender, DependencyPropertyChangedEventArgs e)
		{
			if (d3dimage.IsFrontBufferAvailable) {
				InitializeD3D();  
				CompositionTarget.Rendering += OnRendering;  
				d3dimage.IsFrontBufferAvailableChanged += new DependencyPropertyChangedEventHandler(OnIsFrontBufferAvailableChanged);
				
				d3dimage.Lock();  
				d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, device.GetBackBuffer(0, 0).ComPointer);  
				d3dimage.Unlock();  
			} 
			else {
				CompositionTarget.Rendering -= OnRendering; 
			}
				
		}

		public void RenderD3D()
		{
            Result result;

			try {
                if (d3dimage.IsFrontBufferAvailable)
                {
                    result = device.TestCooperativeLevel();
                    if (result.IsFailure) {
                        throw new Direct3D9Exception();
                    }
                    device.Clear(ClearFlags.Target, new Color4(System.Drawing.Color.Yellow), 0, 0);
                    device.BeginScene();

                    device.EndScene();
                    device.Present();
                }
			}
			catch (Exception ex) {
				string msg = ex.Message;

				InitializeD3D();
				CompositionTarget.Rendering += OnRendering;  
				d3dimage.IsFrontBufferAvailableChanged += new DependencyPropertyChangedEventHandler(OnIsFrontBufferAvailableChanged);
				
				d3dimage.Lock();  
				d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, device.GetBackBuffer(0, 0).ComPointer);  
				d3dimage.Unlock();  
			}
		}
	}
}

HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "test", IntPtr.Zero);  
			
PresentParameters pp = new PresentParameters();  
pp.SwapEffect = SwapEffect.Discard;  
pp.DeviceWindowHandle = hwnd.Handle;  
pp.Windowed = true;  
pp.BackBufferWidth = 400;  
pp.BackBufferHeight = 400;  
pp.BackBufferFormat = Format.X8R8G8B8;
           
device = new DeviceEx(direct3D, 0, 
                    DeviceType.Hardware, 
                    hwnd.Handle, 
                    CreateFlags.HardwareVertexProcessing, 
                    pp);
			
sprite = new Sprite(device); 
texture = Texture.FromFile(device, "pic.jpg");

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Windows.Interop;

using System.Drawing;

using SlimDX;
using SlimDX.Direct3D9;

namespace TriVista.Controls.D3D
{
	/// <summary>
	/// Description of ControlWPF.
	/// </summary>
	public class ControlWPF		:	DockPanel
	{
		// we use it for 3D
		Direct3D direct3D;
		Direct3DEx direct3DEx;
		Device device;  
		DeviceEx deviceEx;
		PresentParameters pp;
		
		// this one is our only child
		System.Windows.Controls.Image image;
		D3DImage d3dimage;
		bool StartThread = false;
		bool sizeChanged = false;
		
		// some public properties
		public bool useDeviceEx
		{
			get;
			private set;
		}
		
		public Direct3D Direct3D
		{
			get {
				if (useDeviceEx)
					return direct3DEx;
				else
					return direct3D;
			}
		}

		public Device Device
		{
			get {
				if (useDeviceEx)
					return deviceEx;
				else
					return device;
			}
		}
		
        #region Events

        /// <summary>
        /// Occurs once per iteration of the main loop.
        /// </summary>
        public event EventHandler MainLoop;

        /// <summary>
        /// Occurs when the device is created.
        /// </summary>
        public event EventHandler DeviceCreated;

        /// <summary>
        /// Occurs when the device is destroyed.
        /// </summary>
        public event EventHandler DeviceDestroyed;

        /// <summary>
        /// Occurs when the device is lost.
        /// </summary>
        public event EventHandler DeviceLost;

        /// <summary>
        /// Occurs when the device is reset.
        /// </summary>
        public event EventHandler DeviceReset;

        /// <summary>
        /// Raises the OnInitialize event.
        /// </summary>
        protected virtual void OnInitialize()
        {
        }
        
        /// <summary>
        /// Raises the <see cref="E:MainLoop"/> event.
        /// </summary>
        protected virtual void OnMainLoop(EventArgs e)
        {
            if (MainLoop != null)
                MainLoop(this, e);
        }

        /// <summary>
        /// Raises the DeviceCreated event.
        /// </summary>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected virtual void OnDeviceCreated(EventArgs e)
        {
            if (DeviceCreated != null)
                DeviceCreated(this, e);
        }

        /// <summary>
        /// Raises the DeviceDestroyed event.
        /// </summary>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected virtual void OnDeviceDestroyed(EventArgs e)
        {
            if (DeviceDestroyed != null)
                DeviceDestroyed(this, e);
        }

        /// <summary>
        /// Raises the DeviceLost event.
        /// </summary>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected virtual void OnDeviceLost(EventArgs e)
        {
            if (DeviceLost != null)
                DeviceLost(this, e);
        }

        /// <summary>
        /// Raises the DeviceReset event.
        /// </summary>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected virtual void OnDeviceReset(EventArgs e)
        {
            if (DeviceReset != null)
                DeviceReset(this, e);
        }
        
        #endregion
        
		public ControlWPF()
		{
			image = new System.Windows.Controls.Image();
			d3dimage = new D3DImage();
			image.Source = d3dimage;
			
			Children.Clear();
			Children.Add(image);
		}
		
		protected override void OnInitialized(EventArgs e)
		{
			base.OnInitialized(e);
			InitializeDirect3D();
		}
		
		protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
		{
			base.OnRenderSizeChanged(sizeInfo);
			sizeChanged = true;
		}
		
		void InitializeDirect3D()
		{
			try {
	            direct3DEx = new Direct3DEx();
	            useDeviceEx = true;
			} catch {
	            direct3D = new Direct3D();
	            useDeviceEx = false;
			}
		}
		
        /// <summary>
        /// Initializes the various Direct3D objects we'll be using.
        /// </summary>
		public bool Initialize(bool startThread)
		{  
			try {
				StartThread = startThread;
				
				ReleaseD3D();
				HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "test", IntPtr.Zero);  
				
				pp = new PresentParameters();  
				pp.SwapEffect = SwapEffect.Discard;  
				pp.DeviceWindowHandle = hwnd.Handle;  
				pp.Windowed = true;  
				pp.BackBufferWidth = (int)ActualWidth;
				pp.BackBufferHeight = (int)ActualHeight;
				pp.BackBufferFormat = Format.X8R8G8B8;
	            
				if (useDeviceEx)
				{
					deviceEx = new DeviceEx((Direct3DEx)Direct3D, 0,
					                    DeviceType.Hardware, 
					                    hwnd.Handle, 
					                    CreateFlags.HardwareVertexProcessing, 
					                    pp);
				}
				else {
					device = new Device(Direct3D, 0, 
					                    DeviceType.Hardware, 
					                    hwnd.Handle, 
					                    CreateFlags.HardwareVertexProcessing, 
					                    pp);
				}
				
				// call the users one
				OnDeviceCreated(EventArgs.Empty);
				OnDeviceReset(EventArgs.Empty);
				
				// only if startThread is true
				if (StartThread) {
					CompositionTarget.Rendering += OnRendering;  
					d3dimage.IsFrontBufferAvailableChanged += new DependencyPropertyChangedEventHandler(OnIsFrontBufferAvailableChanged);
				}
				d3dimage.Lock();  
				d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, Device.GetBackBuffer(0, 0).ComPointer);  
				d3dimage.Unlock();  

				return true;
			}
			catch {
				return false;
			}
		}

		public void ReleaseD3D()
		{
			if (device != null) {
                if (!device.Disposed)
                {
                    device.Dispose();
                    device = null;
                }
			}
            d3dimage.Lock();
            d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, IntPtr.Zero);
            d3dimage.Unlock();
		}
		
		private void OnRendering(object sender, EventArgs e)
		{
            Result result;
	
			try {
                if (Device == null)
                    Initialize(StartThread);
                
                if (sizeChanged) 
                {
					pp.BackBufferWidth = (int)ActualWidth;
					pp.BackBufferHeight = (int)ActualHeight;
					Device.Reset(pp);
					OnDeviceReset(EventArgs.Empty);
                }
				
                if (d3dimage.IsFrontBufferAvailable)
                {
                    result = Device.TestCooperativeLevel();
                    if (result.IsFailure) {
                        throw new Direct3D9Exception();
                    }
					d3dimage.Lock(); 

					Device.Clear(ClearFlags.Target, new Color4(System.Drawing.Color.Yellow), 0, 0);
                    Device.BeginScene();
					// call the users method
					OnMainLoop(EventArgs.Empty);
					
                    Device.EndScene();
                    Device.Present();

                    d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, Device.GetBackBuffer(0, 0).ComPointer);
	                d3dimage.AddDirtyRect(new Int32Rect(0, 0, d3dimage.PixelWidth, d3dimage.PixelHeight));
					d3dimage.Unlock();
                }
			}
			catch (Direct3D9Exception ex) {
				string msg = ex.Message;
				Initialize(StartThread);
			}
        	sizeChanged = false;
		}

		void OnIsFrontBufferAvailableChanged(object sender, DependencyPropertyChangedEventArgs e)
		{
			if (d3dimage.IsFrontBufferAvailable) {
				Initialize(StartThread);  
			} 
			else {
				CompositionTarget.Rendering -= OnRendering; 
			}
		}

	}
}