public static void Hook06000092(Direct3D d3d, TrackBar trackbar, int quality, bool windowed)
{
int adapter = d3d.Adapters.DefaultAdapter.Adapter;
int val;
int val2;
int maxquality;
if (d3d.CheckDeviceMultisampleType(adapter, DeviceType.Hardware, d3d.Adapters[adapter].CurrentDisplayMode.Format, windowed, MultisampleType.NonMaskable, out val) &&
d3d.CheckDeviceMultisampleType(adapter, DeviceType.Hardware, Format.D24S8, windowed, MultisampleType.NonMaskable, out val2))
{
maxquality = Math.Min(val, val2);
}
else
{
maxquality = 0;
}
Capabilities deviceCaps = d3d.GetDeviceCaps(0, DeviceType.Hardware);
trackbar.Enabled = (maxquality > 0);
if (trackbar.Enabled)
{
trackbar.Maximum = maxquality;
try
{
trackbar.Value = (int)Math.Log(quality, 2);
}
catch
{
}
}
}
public static void GetDeviceCaps()
{
// Device.IsUsingEventHandlers = false;
object value = Microsoft.Win32.Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Bethesda Softworks\Morrowind", "Adapter", 0);
adapter = (value != null) ? (int)value : 0;
if (d3d.AdapterCount <= adapter)
{
throw new ApplicationException("Morrowind is set up to use a graphics card which could not be found on your system.");
}
for (int i = 2; i <= 16; i++)
{
if (d3d.CheckDeviceMultisampleType(adapter, DeviceType.Hardware, Format.X8R8G8B8, false, (MultisampleType)i))
{
mCaps.MaxFullscreenAA = i;
}
if (d3d.CheckDeviceMultisampleType(adapter, DeviceType.Hardware, Format.X8R8G8B8, true, (MultisampleType)i))
{
mCaps.MaxWindowedAA = i;
}
}
caps = d3d.GetDeviceCaps(adapter, DeviceType.Hardware);
mCaps.MaxAF = caps.MaxAnisotropy;
mCaps.SupportsSM1 = (caps.VertexShaderVersion >= new Version(1, 1)) && (caps.PixelShaderVersion >= new Version(1, 4));
mCaps.SupportsSM2 = (caps.VertexShaderVersion.Major >= 2) && (caps.PixelShaderVersion.Major >= 2);
mCaps.SupportsSM3 = (caps.VertexShaderVersion.Major >= 3) && (caps.PixelShaderVersion.Major >= 3);
mCaps.MaxTexSize = Math.Min(caps.MaxTextureHeight, caps.MaxTextureWidth);
mCaps.MaxPrimitives = caps.MaxPrimitiveCount;
mCaps.MaxIndicies = caps.MaxVertexIndex;
}
private static PresentParameters CreatePresentParams(Direct3D d3d, IntPtr window, int width, int height)
{
PresentParameters presentParams =
new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
DeviceWindowHandle = window,
BackBufferFormat = Format.A8R8G8B8,
BackBufferWidth = width,
BackBufferHeight = height,
EnableAutoDepthStencil = true,
AutoDepthStencilFormat = Format.D24S8,
};
int msQuality;
if (d3d.CheckDeviceMultisampleType(0, DeviceType.Hardware, Format.A8R8G8B8, true,
MultisampleType.NonMaskable, out msQuality))
{
presentParams.Multisample = MultisampleType.NonMaskable;
presentParams.MultisampleQuality = msQuality - 1;
}
return(presentParams);
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceContext9"/> class.
/// </summary>
/// <param name="handle">The window handle to associate with the device.</param>
/// <param name="settings">The settings used to configure the device.</param>
internal DeviceContext9(IntPtr handle, DeviceSettings9 settings)
{
if (handle == IntPtr.Zero)
throw new ArgumentException("Value must be a valid window handle.", "handle");
if (settings == null)
throw new ArgumentNullException("settings");
this.settings = settings;
PresentParameters = new PresentParameters();
PresentParameters.BackBufferFormat = Format.X8R8G8B8;
PresentParameters.BackBufferCount = 1;
PresentParameters.BackBufferWidth = settings.Width;
PresentParameters.BackBufferHeight = settings.Height;
PresentParameters.Multisample = MultisampleType.None;
PresentParameters.SwapEffect = SwapEffect.Discard;
PresentParameters.EnableAutoDepthStencil = true;
PresentParameters.AutoDepthStencilFormat = Format.D24X8;
PresentParameters.PresentFlags = PresentFlags.DiscardDepthStencil;
PresentParameters.PresentationInterval = PresentInterval.Default;
PresentParameters.Windowed = true;
PresentParameters.DeviceWindowHandle = handle;
direct3D = new Direct3D();
int msaaQuality = 0;
if (direct3D.CheckDeviceMultisampleType(settings.AdapterOrdinal, DeviceType.Hardware, Format.A8R8G8B8, true, MultisampleType.FourSamples, out msaaQuality))
{
this.MultisampleType = SlimDX.Direct3D9.MultisampleType.FourSamples;
this.MultisampleQuality = msaaQuality - 1;
PresentParameters.Multisample = MultisampleType.FourSamples;
PresentParameters.MultisampleQuality = msaaQuality - 1;
}
Device = new Device(direct3D, settings.AdapterOrdinal, DeviceType.Hardware, handle, settings.CreationFlags, PresentParameters);
}
/// <summary>
/// Checks whether the graphics card supports a certain level of anti aliasing
/// </summary>
/// <param name="adapter">The adapter to check</param>
/// <param name="sample">The sample level to check</param>
/// <returns><c>true</c> if the level is supported</returns>
public static bool CheckAA(int adapter, int sample)
{
using (var manager = new Direct3D())
{
return(manager.CheckDeviceMultisampleType(adapter, DeviceType.Hardware,
manager.Adapters[adapter].CurrentDisplayMode.Format, true, (MultisampleType)sample));
}
}
private bool CheckDeviceType(Direct3D d3d, out DeviceType dType, out MultisampleType mType, out int mQuality)
{
dType = DeviceType.Hardware;
mType = MultisampleType.EightSamples;
mQuality = 0;
//if (!d3d.CheckDeviceType(0, dType, Format.X8R8G8B8, Format.D16, true))
//{
// dType = DeviceType.Reference;
// if (!d3d.CheckDeviceType(0, dType, Format.X8R8G8B8, Format.D16, true))
// return false;
//}
if (!d3d.CheckDeviceMultisampleType(0, dType, Format.X8R8G8B8, true, mType, out mQuality) ||
!d3d.CheckDeviceMultisampleType(0, dType, Format.D16, true, mType, out mQuality) ||
mQuality < 1)
{
mType = MultisampleType.FourSamples;
if (!d3d.CheckDeviceMultisampleType(0, dType, Format.X8R8G8B8, true, mType, out mQuality) ||
!d3d.CheckDeviceMultisampleType(0, dType, Format.D16, true, mType, out mQuality) ||
mQuality < 1)
{
mType = MultisampleType.TwoSamples;
if (!d3d.CheckDeviceMultisampleType(0, dType, Format.X8R8G8B8, true, mType, out mQuality) ||
!d3d.CheckDeviceMultisampleType(0, dType, Format.D16, true, mType, out mQuality) ||
mQuality < 1)
{
mType = MultisampleType.None;
}
}
}
return(true);
}
/* Hook DirectX Device Creation */
private IntPtr CreateDeviceImpl(IntPtr direct3DPointer, uint adapter, DeviceType deviceType, IntPtr hFocusWindow, CreateFlags behaviorFlags, ref PresentParameters pPresentationParameters, int **ppReturnedDeviceInterface)
{
// Get D3D Interface (IDirect3D9)
Direct3D d3d = new Direct3D(direct3DPointer);
// Enable Hardware Vertex Processing..
if (_dx9Settings.HardwareVertexProcessing)
{
behaviorFlags = behaviorFlags & ~CreateFlags.SoftwareVertexProcessing;
behaviorFlags = behaviorFlags | CreateFlags.HardwareVertexProcessing;
}
// Get and Set max MSAA Quality
if (_dx9Settings.EnableMSAA)
{
bool msaaAvailable = d3d.CheckDeviceMultisampleType(0, DeviceType.Hardware, pPresentationParameters.BackBufferFormat,
pPresentationParameters.Windowed, (MultisampleType)_dx9Settings.MSAALevel, out maxMSAAQuality);
if (!msaaAvailable)
{
Bindings.PrintError($"The user set MSAA Setting ({_dx9Settings.MSAALevel} Samples) is not supported on this hardware configuration.");
Bindings.PrintError($"MSAA will be disabled.");
_dx9Settings.EnableMSAA = false;
}
if (maxMSAAQuality > 0)
{
maxMSAAQuality -= 1;
}
}
// Check for AF Compatibility
if (_dx9Settings.EnableAF)
{
var capabilities = d3d.GetDeviceCaps(0, DeviceType.Hardware);
if (_dx9Settings.AFLevel > capabilities.MaxAnisotropy)
{
Bindings.PrintError($"The user set Anisotropic Filtering Setting ({_dx9Settings.AFLevel} Samples) is not supported on this hardware configuration.");
Bindings.PrintError($"AF will be disabled.");
_dx9Settings.EnableAF = false;
}
}
// Set present parameters.
pPresentationParameters = SetPresentParameters(ref pPresentationParameters);
return(_createDeviceHook.OriginalFunction(direct3DPointer, adapter, deviceType, hFocusWindow, behaviorFlags, ref pPresentationParameters, ppReturnedDeviceInterface));
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceContext9"/> class.
/// </summary>
/// <param name="handle">The window handle to associate with the device.</param>
/// <param name="settings">The settings used to configure the device.</param>
internal DeviceContext9(IntPtr handle, DeviceSettings9 settings)
{
if (handle == IntPtr.Zero)
{
throw new ArgumentException("Value must be a valid window handle.", "handle");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
PresentParameters = new PresentParameters();
PresentParameters.BackBufferFormat = Format.X8R8G8B8;
PresentParameters.BackBufferCount = 1;
PresentParameters.BackBufferWidth = settings.Width;
PresentParameters.BackBufferHeight = settings.Height;
PresentParameters.Multisample = MultisampleType.None;
PresentParameters.SwapEffect = SwapEffect.Discard;
PresentParameters.EnableAutoDepthStencil = true;
PresentParameters.AutoDepthStencilFormat = Format.D24X8;
PresentParameters.PresentFlags = PresentFlags.DiscardDepthStencil;
PresentParameters.PresentationInterval = PresentInterval.Default;
PresentParameters.Windowed = true;
PresentParameters.DeviceWindowHandle = handle;
direct3D = new Direct3D();
int msaaQuality = 0;
if (direct3D.CheckDeviceMultisampleType(settings.AdapterOrdinal, DeviceType.Hardware, Format.A8R8G8B8, true, MultisampleType.FourSamples, out msaaQuality))
{
this.MultisampleType = SlimDX.Direct3D9.MultisampleType.FourSamples;
this.MultisampleQuality = msaaQuality - 1;
PresentParameters.Multisample = MultisampleType.FourSamples;
PresentParameters.MultisampleQuality = msaaQuality - 1;
}
Device = new Device(direct3D, settings.AdapterOrdinal, DeviceType.Hardware, handle, settings.CreationFlags, PresentParameters);
}
/// <summary>
/// Sets the highest MultisampleType.
/// </summary>
/// <param name="presentParameters">The PresentParameters.</param>
private void SetHighestMultisampleType(PresentParameters presentParameters)
{
var possibleMultisampleTypes = new List <MultisampleType>
{
MultisampleType.None,
MultisampleType.NonMaskable,
MultisampleType.TwoSamples,
MultisampleType.ThreeSamples,
MultisampleType.FourSamples,
MultisampleType.FiveSamples,
MultisampleType.SixSamples,
MultisampleType.SevenSamples,
MultisampleType.EightSamples,
MultisampleType.NineSamples,
MultisampleType.TenSamples,
MultisampleType.ElevenSamples,
MultisampleType.TwelveSamples,
MultisampleType.ThirteenSamples,
MultisampleType.FourteenSamples,
MultisampleType.FifteenSamples,
MultisampleType.SixteenSamples
};
var highestSample = MultisampleType.None;
int qualityLevel = 0;
foreach (MultisampleType sampleType in possibleMultisampleTypes)
{
if (_direct3D.CheckDeviceMultisampleType(_direct3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware,
Format.A8R8G8B8, true, sampleType, out qualityLevel))
{
highestSample = sampleType;
}
}
presentParameters.Multisample = highestSample;
presentParameters.MultisampleQuality = qualityLevel;
}
static public void Hook06000005(ref Direct3D d3d, ref Device device, ref PresentParameters param, Control control, bool windowed, Size size, int quality)
{
fullscreen |= !windowed;
d3d = new Direct3D();
int adapter = d3d.Adapters.DefaultAdapter.Adapter;
Capabilities deviceCaps = d3d.GetDeviceCaps(adapter, DeviceType.Hardware);
DeviceType deviceType = deviceCaps.DeviceType;
CreateFlags createFlags = (deviceCaps.VertexShaderVersion >= new Version(2, 0)) ? CreateFlags.HardwareVertexProcessing : CreateFlags.SoftwareVertexProcessing;
param = new PresentParameters();
param.SwapEffect = SwapEffect.Discard;
DisplayMode currentDisplayMode = d3d.Adapters[adapter].CurrentDisplayMode;
param.Windowed = (windowed || !d3d.CheckDeviceType(adapter, DeviceType.Hardware, currentDisplayMode.Format, currentDisplayMode.Format, false));
if (param.Windowed)
{
param.DeviceWindowHandle = control.Handle;
if (!fullscreen)
{
param.BackBufferWidth = 0;
param.BackBufferHeight = 0;
}
else
{
param.BackBufferWidth = size.Width;
param.BackBufferHeight = size.Height;
control.ClientSize = new Size(currentDisplayMode.Width, currentDisplayMode.Height);
control.Location = new Point(0, 0);
}
}
else
{
param.BackBufferFormat = currentDisplayMode.Format;
param.BackBufferCount = 1;
if (size.Width == 0 || size.Height == 0)
{
size = new Size(currentDisplayMode.Width, currentDisplayMode.Height);
}
param.BackBufferWidth = size.Width;
param.BackBufferHeight = size.Height;
param.PresentFlags = PresentFlags.LockableBackBuffer;
control.ClientSize = new Size(currentDisplayMode.Width, currentDisplayMode.Height);
control.Location = new Point(0, 0);
}
if (d3d.CheckDeviceFormat(adapter, DeviceType.Hardware, currentDisplayMode.Format, Usage.DepthStencil, ResourceType.Surface, Format.D24S8))
{
param.EnableAutoDepthStencil = true;
param.AutoDepthStencilFormat = Format.D24S8;
}
MultisampleType multisampleType = quality <= 1 ? MultisampleType.None : MultisampleType.NonMaskable;
while (multisampleType > MultisampleType.None)
{
int val;
int val2;
if (d3d.CheckDeviceMultisampleType(adapter, deviceType, param.BackBufferFormat, param.Windowed, multisampleType, out val) && d3d.CheckDeviceMultisampleType(adapter, deviceType, Format.D24S8, param.Windowed, multisampleType, out val2))
{
param.Multisample = multisampleType;
if (multisampleType == MultisampleType.NonMaskable)
{
param.MultisampleQuality = Math.Min(Math.Min(val, val2) - 1, (int)Math.Log(quality, 2) - 1);
break;
}
break;
}
else
{
multisampleType--;
}
}
param.PresentationInterval = PresentInterval.One;
device = new Device(d3d, adapter, deviceType, control.Handle, createFlags, new PresentParameters[] { param });
}
/// <summary>
/// Initializes the Device
/// </summary>
private void InitializeDevice(int width, int height)
{
if (DirectXStatus != DirectXStatus.Available)
{
return;
}
Debug.Assert(Direct3D != null);
ReleaseDevice();
IntPtr windowHandle = (new Form()).Handle;
//HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, width, height, "SharpDXControl", IntPtr.Zero);
presentParameters = new PresentParameters();
if (UseDeviceEx)
{
presentParameters.SwapEffect = SwapEffect.Discard;
}
else
{
presentParameters.SwapEffect = SwapEffect.Copy;
}
presentParameters.DeviceWindowHandle = windowHandle;
presentParameters.Windowed = true;
presentParameters.BackBufferWidth = Math.Max(width, 1);
presentParameters.BackBufferHeight = Math.Max(height, 1);
presentParameters.BackBufferFormat = backbufferFormat;
presentParameters.AutoDepthStencilFormat = depthStencilFormat;
presentParameters.EnableAutoDepthStencil = true;
presentParameters.PresentationInterval = PresentInterval.Immediate;
presentParameters.MultiSampleType = MultisampleType.None;
IsAntialiased = false;
int qualityLevels;
if (Direct3D.CheckDeviceMultisampleType(0, DeviceType.Hardware, backbufferFormat, true, MultisampleType.EightSamples, out qualityLevels))
{
presentParameters.MultiSampleType = MultisampleType.EightSamples;
presentParameters.MultiSampleQuality = qualityLevels - 1;
IsAntialiased = true;
}
else if (Direct3D.CheckDeviceMultisampleType(0, DeviceType.Hardware, backbufferFormat, true, MultisampleType.FourSamples, out qualityLevels))
{
presentParameters.MultiSampleType = MultisampleType.FourSamples;
presentParameters.MultiSampleQuality = qualityLevels - 1;
IsAntialiased = false;
}
try
{
if (UseDeviceEx)
{
deviceEx = new DeviceEx((Direct3DEx)Direct3D, 0,
DeviceType.Hardware,
windowHandle,
createFlags,
presentParameters);
}
else
{
device = new Device(Direct3D, 0,
DeviceType.Hardware,
windowHandle,
createFlags,
presentParameters);
}
}
catch (Exception) //Direct3D9Exception
{
DirectXStatus = DirectXStatus.Unavailable_Unknown;
return;
}
return;
}
/// <summary>
/// Creates a new Instance of the CDirect3D Class
/// </summary>
public CDirect3D()
{
this.Icon = new System.Drawing.Icon(Path.Combine(System.Environment.CurrentDirectory, CSettings.sIcon));
_Textures = new List<STexture>();
_D3DTextures = new List<Texture>();
_Queque = new List<STextureQueque>();
_Keys = new CKeys();
_D3D = new Direct3D();
this.Paint += new PaintEventHandler(this.OnPaintEvent);
this.Closing += new CancelEventHandler(this.OnClosingEvent);
this.Resize += new EventHandler(this.OnResizeEvent);
this.KeyDown += new KeyEventHandler(this.OnKeyDown);
this.PreviewKeyDown += new PreviewKeyDownEventHandler(this.OnPreviewKeyDown);
this.KeyPress += new KeyPressEventHandler(this.OnKeyPress);
this.KeyUp += new KeyEventHandler(this.OnKeyUp);
_Mouse = new CMouse();
this.MouseMove += new MouseEventHandler(this.OnMouseMove);
this.MouseWheel += new MouseEventHandler(this.OnMouseWheel);
this.MouseDown += new MouseEventHandler(this.OnMouseDown);
this.MouseUp += new MouseEventHandler(this.OnMouseUp);
this.MouseLeave += new EventHandler(this.OnMouseLeave);
this.MouseEnter += new EventHandler(this.OnMouseEnter);
this.ClientSize = new Size(CConfig.ScreenW, CConfig.ScreenH);
_SizeBeforeMinimize = ClientSize;
_PresentParameters = new PresentParameters();
_PresentParameters.Windowed = true;
_PresentParameters.SwapEffect = SwapEffect.Discard;
_PresentParameters.BackBufferHeight = CConfig.ScreenH;
_PresentParameters.BackBufferWidth = CConfig.ScreenW;
_PresentParameters.BackBufferFormat = _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format;
_PresentParameters.Multisample = MultisampleType.None;
_PresentParameters.MultisampleQuality = 0;
//Apply antialiasing and check if antialiasing mode is supported
#region Antialiasing
int quality = 0;
if (CConfig.AAMode == EAntiAliasingModes.x0)
{
_PresentParameters.Multisample = MultisampleType.None;
_PresentParameters.MultisampleQuality = quality;
}
else if (CConfig.AAMode == EAntiAliasingModes.x2)
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.TwoSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.TwoSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
else if (CConfig.AAMode == EAntiAliasingModes.x4)
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.FourSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.FourSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
else if (CConfig.AAMode == EAntiAliasingModes.x8)
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.EightSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.EightSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
else if (CConfig.AAMode == EAntiAliasingModes.x16 || CConfig.AAMode == EAntiAliasingModes.x32) //x32 is not supported, fallback to x16
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.SixteenSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.SixteenSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
#endregion Antialiasing
//Apply the VSync configuration
if (CConfig.VSync == EOffOn.TR_CONFIG_ON)
_PresentParameters.PresentationInterval = PresentInterval.Default;
else
_PresentParameters.PresentationInterval = PresentInterval.Immediate;
//GMA 950 graphics devices can only process vertices in software mode
Capabilities caps = _D3D.GetDeviceCaps(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware);
CreateFlags flags = CreateFlags.None;
if ((caps.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
flags = CreateFlags.HardwareVertexProcessing;
else
flags = CreateFlags.SoftwareVertexProcessing;
_Device = new Device(_D3D, _D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, Handle, flags, _PresentParameters);
this.CenterToScreen();
//This creates a new white texture and adds it to the texture pool
//This texture is used for the DrawRect method
blankMap = new Bitmap(1, 1);
Graphics g = Graphics.FromImage(blankMap);
g.Clear(Color.White);
g.Dispose();
blankTexture = AddTexture(blankMap);
transparentTexture = new Texture(_Device, 1, 1, 0, Usage.None, Format.A8R8G8B8, Pool.Managed);
blankMap.Dispose();
}
/// <summary>
/// Creates a new Instance of the CDirect3D Class
/// </summary>
public CDirect3D()
{
this.Icon = new System.Drawing.Icon(Path.Combine(System.Environment.CurrentDirectory, CSettings.sIcon));
_Textures = new Dictionary<int, STexture>();
_D3DTextures = new Dictionary<int, Texture>();
_Queque = new List<STextureQueque>();
_IDs = new Queue<int>();
//Fill Queue with 100000 IDs
for (int i = 0; i < 100000; i++)
_IDs.Enqueue(i);
_Vertices = new Queue<TexturedColoredVertex>();
_VerticesTextures = new Queue<Texture>();
_VerticesRotationMatrices = new Queue<Matrix>();
_Keys = new CKeys();
try
{
_D3D = new Direct3D();
}
catch (Direct3D9NotFoundException e)
{
MessageBox.Show("No DirectX runtimes were found, please download and install them " +
"from http://www.microsoft.com/download/en/details.aspx?id=8109",
CSettings.sProgramName, MessageBoxButtons.OK, MessageBoxIcon.Error);
CLog.LogError(e.Message + " - No DirectX runtimes were found, please download and install them from http://www.microsoft.com/download/en/details.aspx?id=8109");
Environment.Exit(Environment.ExitCode);
}
this.Paint += new PaintEventHandler(this.OnPaintEvent);
this.Closing += new CancelEventHandler(this.OnClosingEvent);
this.Resize += new EventHandler(this.OnResizeEvent);
this.KeyDown += new KeyEventHandler(this.OnKeyDown);
this.PreviewKeyDown += new PreviewKeyDownEventHandler(this.OnPreviewKeyDown);
this.KeyPress += new KeyPressEventHandler(this.OnKeyPress);
this.KeyUp += new KeyEventHandler(this.OnKeyUp);
_Mouse = new CMouse();
this.MouseMove += new MouseEventHandler(this.OnMouseMove);
this.MouseWheel += new MouseEventHandler(this.OnMouseWheel);
this.MouseDown += new MouseEventHandler(this.OnMouseDown);
this.MouseUp += new MouseEventHandler(this.OnMouseUp);
this.MouseLeave += new EventHandler(this.OnMouseLeave);
this.MouseEnter += new EventHandler(this.OnMouseEnter);
this.ClientSize = new Size(CConfig.ScreenW, CConfig.ScreenH);
_SizeBeforeMinimize = ClientSize;
_PresentParameters = new PresentParameters();
_PresentParameters.Windowed = true;
_PresentParameters.SwapEffect = SwapEffect.Discard;
_PresentParameters.BackBufferHeight = CConfig.ScreenH;
_PresentParameters.BackBufferWidth = CConfig.ScreenW;
_PresentParameters.BackBufferFormat = _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format;
_PresentParameters.Multisample = MultisampleType.None;
_PresentParameters.MultisampleQuality = 0;
//Apply antialiasing and check if antialiasing mode is supported
#region Antialiasing
int quality = 0;
if (CConfig.AAMode == EAntiAliasingModes.x0)
{
_PresentParameters.Multisample = MultisampleType.None;
_PresentParameters.MultisampleQuality = quality;
}
else if (CConfig.AAMode == EAntiAliasingModes.x2)
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.TwoSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.TwoSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
else if (CConfig.AAMode == EAntiAliasingModes.x4)
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.FourSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.FourSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
else if (CConfig.AAMode == EAntiAliasingModes.x8)
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.EightSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.EightSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
else if (CConfig.AAMode == EAntiAliasingModes.x16 || CConfig.AAMode == EAntiAliasingModes.x32) //x32 is not supported, fallback to x16
{
if (_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, MultisampleType.SixteenSamples, out quality))
{
_PresentParameters.Multisample = MultisampleType.SixteenSamples;
_PresentParameters.MultisampleQuality = quality - 1;
}
else
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
}
#endregion Antialiasing
//Apply the VSync configuration
if (CConfig.VSync == EOffOn.TR_CONFIG_ON)
_PresentParameters.PresentationInterval = PresentInterval.Default;
else
_PresentParameters.PresentationInterval = PresentInterval.Immediate;
//GMA 950 graphics devices can only process vertices in software mode
Capabilities caps = _D3D.GetDeviceCaps(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware);
CreateFlags flags = CreateFlags.None;
if ((caps.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
flags = CreateFlags.HardwareVertexProcessing;
else
flags = CreateFlags.SoftwareVertexProcessing;
try
{
_Device = new Device(_D3D, _D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, Handle, flags, _PresentParameters);
}
catch (Exception e)
{
MessageBox.Show("Something went wrong during device creating, please check if your DirectX redistributables " +
"and graphic card drivers are up to date. You can download the DirectX runtimes at http://www.microsoft.com/download/en/details.aspx?id=8109",
CSettings.sProgramName, MessageBoxButtons.OK, MessageBoxIcon.Error);
CLog.LogError(e.Message + " - Something went wrong during device creating, please check if your DirectX redistributables and grafic card drivers are up to date. You can download the DirectX runtimes at http://www.microsoft.com/download/en/details.aspx?id=8109");
Environment.Exit(Environment.ExitCode);
}
finally
{
if (_Device == null || _Device.Disposed)
{
MessageBox.Show("Something went wrong during device creating, please check if your DirectX redistributables " +
"and graphic card drivers are up to date. You can download the DirectX runtimes at http://www.microsoft.com/download/en/details.aspx?id=8109",
CSettings.sProgramName, MessageBoxButtons.OK, MessageBoxIcon.Error);
CLog.LogError("Something went wrong during device creating, please check if your DirectX redistributables and grafic card drivers are up to date. You can download the DirectX runtimes at http://www.microsoft.com/download/en/details.aspx?id=8109");
Environment.Exit(Environment.ExitCode);
}
}
this.CenterToScreen();
}
/// <summary>
/// Creates a new Instance of the CDirect3D Class
/// </summary>
public CDirect3D()
{
_Form = new CRenderFormHook {
ClientSize = new Size(CConfig.Config.Graphics.ScreenW, CConfig.Config.Graphics.ScreenH)
};
try
{
_D3D = new Direct3D();
}
catch (Direct3DX9NotFoundException e)
{
CLog.LogError("No DirectX runtimes were found, please download and install them from http://www.microsoft.com/download/en/details.aspx?id=8109", true, true, e);
}
_Form.KeyDown += _OnKeyDown;
_Form.PreviewKeyDown += _OnPreviewKeyDown;
_Form.KeyPress += _OnKeyPress;
_Form.KeyUp += _OnKeyUp;
_Form.MouseMove += _OnMouseMove;
_Form.MouseWheel += _OnMouseWheel;
_Form.MouseDown += _OnMouseDown;
_Form.MouseUp += _OnMouseUp;
_Form.MouseLeave += _OnMouseLeave;
_Form.MouseEnter += _OnMouseEnter;
_PresentParameters = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
BackBufferHeight = CConfig.Config.Graphics.ScreenH,
BackBufferWidth = CConfig.Config.Graphics.ScreenW,
BackBufferFormat = _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format,
Multisample = MultisampleType.None,
MultisampleQuality = 0
};
//Apply antialiasing and check if antialiasing mode is supported
#region Antialiasing
int quality;
MultisampleType msType;
switch (CConfig.Config.Graphics.AAMode)
{
case EAntiAliasingModes.X2:
msType = MultisampleType.TwoSamples;
break;
case EAntiAliasingModes.X4:
msType = MultisampleType.FourSamples;
break;
case EAntiAliasingModes.X8:
msType = MultisampleType.EightSamples;
break;
case EAntiAliasingModes.X16:
case EAntiAliasingModes.X32: //x32 is not supported, fallback to x16
msType = MultisampleType.SixteenSamples;
break;
default:
msType = MultisampleType.None;
break;
}
if (
!_D3D.CheckDeviceMultisampleType(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _D3D.Adapters.DefaultAdapter.CurrentDisplayMode.Format, false, msType,
out quality))
{
CLog.LogError("[Direct3D] This AAMode is not supported by this device or driver, fallback to no AA");
msType = MultisampleType.None;
quality = 1;
}
_PresentParameters.Multisample = msType;
_PresentParameters.MultisampleQuality = quality - 1;
#endregion Antialiasing
//Apply the VSync configuration
_PresentParameters.PresentationInterval = CConfig.Config.Graphics.VSync == EOffOn.TR_CONFIG_ON ? PresentInterval.Default : PresentInterval.Immediate;
//GMA 950 graphics devices can only process vertices in software mode
Capabilities caps = _D3D.GetDeviceCaps(_D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware);
CreateFlags flags = (caps.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0 ? CreateFlags.HardwareVertexProcessing : CreateFlags.SoftwareVertexProcessing;
//Check if Pow2 textures are needed
_NonPowerOf2TextureSupported = true;
_NonPowerOf2TextureSupported &= (caps.TextureCaps & TextureCaps.Pow2) == 0;
_NonPowerOf2TextureSupported &= (caps.TextureCaps & TextureCaps.NonPow2Conditional) == 0;
_NonPowerOf2TextureSupported &= (caps.TextureCaps & TextureCaps.SquareOnly) == 0;
try
{
_Device = new Device(_D3D, _D3D.Adapters.DefaultAdapter.Adapter, DeviceType.Hardware, _Form.Handle, flags, _PresentParameters);
}
catch (Exception e)
{
CLog.LogError("Error during D3D device creation.", false, false, e);
}
finally
{
if (_Device == null || _Device.Disposed)
{
CLog.LogError(
"Something went wrong during device creating, please check if your DirectX redistributables and grafic card drivers are up to date. You can download the DirectX runtimes at http://www.microsoft.com/download/en/details.aspx?id=8109",
true, true);
}
}
}
// This initializes the graphics
public bool Initialize()
{
// Use default adapter
this.adapter = 0; // Manager.Adapters.Default.Adapter;
try
{
// Make present parameters
PresentParameters displaypp = CreatePresentParameters(adapter);
// Determine device type for compatability with NVPerfHUD
DeviceType devtype;
if (d3d.Adapters[adapter].Details.Description.EndsWith(NVPERFHUD_ADAPTER))
{
devtype = DeviceType.Reference;
}
else
{
devtype = DeviceType.Hardware;
}
//mxd. Check maximum supported AA level...
for (int i = AA_STEPS.Count - 1; i > 0; i--)
{
if (General.Settings.AntiAliasingSamples < AA_STEPS[i])
{
continue;
}
if (d3d.CheckDeviceMultisampleType(this.adapter, devtype, d3d.Adapters[adapter].CurrentDisplayMode.Format, displaypp.Windowed, (MultisampleType)AA_STEPS[i]))
{
break;
}
if (General.Settings.AntiAliasingSamples > AA_STEPS[i - 1])
{
General.Settings.AntiAliasingSamples = AA_STEPS[i - 1];
// TODO: looks like setting Multisample here just resets it to MultisampleType.None,
// regardless of value in displaypp.Multisample. Why?..
displaypp.Multisample = (MultisampleType)General.Settings.AntiAliasingSamples;
}
}
// Get the device capabilities
devicecaps = d3d.GetDeviceCaps(adapter, devtype);
// Check if this adapter supports TnL
if ((devicecaps.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
{
// Initialize with hardware TnL
device = new Device(d3d, adapter, devtype, rendertarget.Handle,
CreateFlags.HardwareVertexProcessing, displaypp);
}
else
{
// Initialize with software TnL
device = new Device(d3d, adapter, devtype, rendertarget.Handle,
CreateFlags.SoftwareVertexProcessing, displaypp);
}
}
catch (Exception)
{
// Failed
MessageBox.Show(General.MainWindow, "Unable to initialize the Direct3D video device. Another application may have taken exclusive mode on this video device or the device does not support Direct3D at all.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
//mxd. Check if we can use shaders
if (device.Capabilities.PixelShaderVersion.Major < 2)
{
// Failed
MessageBox.Show(General.MainWindow, "Unable to initialize the Direct3D video device. Video device with Shader Model 2.0 support is required.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
// Add event to cancel resize event
//device.DeviceResizing += new CancelEventHandler(CancelResize);
// Keep a reference to the original buffers
backbuffer = device.GetBackBuffer(0, 0);
depthbuffer = device.DepthStencilSurface;
// Get the viewport
viewport = device.Viewport;
// Create shader manager
shaders = new ShaderManager(this);
// Initialize settings
SetupSettings();
// Done
return(true);
}
/// <summary>
/// Checks whether the graphics card supports a certain level of anti aliasing
/// </summary>
/// <param name="sample">The sample level to check</param>
/// <returns><c>true</c> if the level is supported</returns>
public bool CheckAA(int sample)
{
return(_direct3D.CheckDeviceMultisampleType(_engineConfig.Adapter, DeviceType.Hardware,
_direct3D.Adapters[_engineConfig.Adapter].CurrentDisplayMode.Format, true, (MultisampleType)sample));
}
