d3denumeration.cs

Particle System Test Application on C#

//-----------------------------------------------------------------------------
// File: D3DEnumeration.cs
//
// Desc: Enumerates D3D adapters, devices, modes, etc.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
using System;
using System.Collections;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;




/// <summary>
/// Enumeration of all possible D3D vertex processing types
/// </summary>
public enum VertexProcessingType
{
	Software,
	Mixed,
	Hardware,
	PureHardware
}




/// <summary>
/// Info about a display adapter
/// </summary>
public class GraphicsAdapterInfo
{
	public int AdapterOrdinal;
	public AdapterDetails AdapterDetails;
	public ArrayList DisplayModeList = new ArrayList(); // List of D3DDISPLAYMODEs
	public ArrayList DeviceInfoList = new ArrayList(); // List of D3DDeviceInfos
	public override string ToString() { return AdapterDetails.Description; }
}




/// <summary>
/// Info about a D3D device, including a list of DeviceCombos (see below) 
/// that work with the device
/// </summary>
public class GraphicsDeviceInfo
{
	public int AdapterOrdinal;
	public DeviceType DevType;
	public Caps Caps;
	public ArrayList DeviceComboList = new ArrayList(); // List of D3DDeviceCombos
	public override string ToString() { return DevType.ToString(); }
}




/// <summary>
/// Info about a depth/stencil buffer format that is incompatible with a
/// multisample type
/// </summary>
public class DepthStencilMultiSampleConflict
{
	public DepthFormat DepthStencilFormat;
	public MultiSampleType MultiSampleType;
}




/// <summary>
/// A combination of adapter format, back buffer format, and windowed/fullscreen 
/// that is compatible with a particular D3D device (and the app)
/// </summary>
public class DeviceCombo
{
	public int AdapterOrdinal;
	public DeviceType DevType;
	public Format AdapterFormat;
	public Format BackBufferFormat;
	public bool IsWindowed;
	public ArrayList DepthStencilFormatList = new ArrayList(); // List of D3DFORMATs
	public ArrayList MultiSampleTypeList = new ArrayList(); // List of D3DMULTISAMPLE_TYPEs
	public ArrayList MultiSampleQualityList = new ArrayList(); // List of ints (maxQuality per multisample type)
	public ArrayList DepthStencilMultiSampleConflictList = new ArrayList(); // List of DepthStencilMultiSampleConflicts
	public ArrayList VertexProcessingTypeList = new ArrayList(); // List of VertexProcessingTypes
	public ArrayList PresentIntervalList = new ArrayList(); // List of D3DPRESENT_INTERVALs
}




/// <summary>
/// Used to sort Displaymodes
/// </summary>
class DisplayModeComparer : System.Collections.IComparer
{
    /// <summary>
    /// Compare two display modes
    /// </summary>
	public int Compare(object x, object y)
	{
		DisplayMode dx = (DisplayMode)x;
		DisplayMode dy = (DisplayMode)y;

		if (dx.Width > dy.Width)
			return 1;
		if (dx.Width < dy.Width)
			return -1;
		if (dx.Height > dy.Height)
			return 1;
		if (dx.Height < dy.Height)
			return -1;
		if (dx.Format > dy.Format)
			return 1;
		if (dx.Format < dy.Format)
			return -1;
		if (dx.RefreshRate > dy.RefreshRate)
			return 1;
		if (dx.RefreshRate < dy.RefreshRate)
			return -1;
		return 0;
	}
}




/// <summary>
/// Enumerates available adapters, devices, modes, etc.
/// </summary>
public class D3DEnumeration
{
    /// <summary>
    /// The confirm device delegate which is used to determine if a device 
    /// meets the needs of the simulation
    /// </summary>
	public delegate bool ConfirmDeviceCallbackType(Caps caps, 
		VertexProcessingType vertexProcessingType, Format adapterFormat, 
		Format backBufferFormat);

	public ConfirmDeviceCallbackType ConfirmDeviceCallback;
	public ArrayList AdapterInfoList = new ArrayList(); // List of D3DAdapterInfos

	// The following variables can be used to limit what modes, formats, 
	// etc. are enumerated.  Set them to the values you want before calling
	// Enumerate().
	public int AppMinFullscreenWidth = 640;
	public int AppMinFullscreenHeight = 480;
	public int AppMinColorChannelBits = 5; // min color bits per channel in adapter format
	public int AppMinAlphaChannelBits = 0; // min alpha bits per pixel in back buffer format
	public int AppMinDepthBits = 15;
	public int AppMinStencilBits = 0;
	public bool AppUsesDepthBuffer = true;
	public bool AppUsesMixedVP = false; // whether app can take advantage of mixed vp mode
	public bool AppRequiresWindowed = false;
	public bool AppRequiresFullscreen = false;


    
    
    /// <summary>
	/// Enumerates available D3D adapters, devices, modes, etc.
	/// </summary>
	public void Enumerate()
	{
		foreach (AdapterInformation ai in Manager.Adapters)
		{
			ArrayList adapterFormatList = new ArrayList();
			GraphicsAdapterInfo adapterInfo = new GraphicsAdapterInfo();
			adapterInfo.AdapterOrdinal = ai.Adapter;
			adapterInfo.AdapterDetails = ai.Information;

			// Get list of all display modes on this adapter.  
			// Also build a temporary list of all display adapter formats.
		    foreach (DisplayMode displayMode in ai.SupportedDisplayModes)
		    {
			    if (displayMode.Width < AppMinFullscreenWidth)
				    continue;
			    if (displayMode.Height < AppMinFullscreenHeight)
				    continue;
			    if (GraphicsUtility.GetColorChannelBits(displayMode.Format) < AppMinColorChannelBits)
				    continue;
			    adapterInfo.DisplayModeList.Add(displayMode);
			    if (!adapterFormatList.Contains(displayMode.Format))
				    adapterFormatList.Add(displayMode.Format);
		    }

			// Sort displaymode list
			DisplayModeComparer dmc = new DisplayModeComparer();
			adapterInfo.DisplayModeList.Sort(dmc);

			// Get info for each device on this adapter
			EnumerateDevices(adapterInfo, adapterFormatList);

			// If at least one device on this adapter is available and compatible
			// with the app, add the adapterInfo to the list
			if (adapterInfo.DeviceInfoList.Count == 0)
				continue;
			AdapterInfoList.Add(adapterInfo);
		}
	}


    
    
    /// <summary>
	/// Enumerates D3D devices for a particular adapter
	/// </summary>
	protected void EnumerateDevices(GraphicsAdapterInfo adapterInfo, ArrayList adapterFormatList)
	{
		DeviceType[] devTypeArray = new DeviceType[] 
			{ DeviceType.Hardware, DeviceType.Software, DeviceType.Reference };

		foreach (DeviceType devType in devTypeArray)
		{
			GraphicsDeviceInfo deviceInfo = new GraphicsDeviceInfo();
			deviceInfo.AdapterOrdinal = adapterInfo.AdapterOrdinal;
			deviceInfo.DevType = devType;
			try
			{
				deviceInfo.Caps = Manager.GetDeviceCaps(adapterInfo.AdapterOrdinal, devType);
			}
			catch (DirectXException)
			{
				continue;
			}

			// Get info for each devicecombo on this device
			EnumerateDeviceCombos(deviceInfo, adapterFormatList);

			// If at least one devicecombo for this device is found, 
			// add the deviceInfo to the list
			if (deviceInfo.DeviceComboList.Count == 0)
				continue;
			adapterInfo.DeviceInfoList.Add(deviceInfo);
		}
	}


    
    
    /// <summary>
	/// Enumerates DeviceCombos for a particular device
	/// </summary>