private void Initialize3D()
{
HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "D3", IntPtr.Zero);
pp.SwapEffect = SwapEffect.Discard;
pp.DeviceWindowHandle = hwnd.Handle;
pp.Windowed = true;
pp.BackBufferWidth = (int)ActualWidth;
pp.BackBufferHeight = (int)ActualHeight;
pp.BackBufferFormat = Format.X8R8G8B8;
try
{
var direct3DEx = new Direct3DEx();
direct3D = direct3DEx;
device = new DeviceEx(direct3DEx, 0, DeviceType.Hardware, hwnd.Handle, CreateFlags.HardwareVertexProcessing, pp);
}
catch
{
direct3D = new Direct3D();
device = new Device(direct3D, 0, DeviceType.Hardware, hwnd.Handle, CreateFlags.HardwareVertexProcessing, pp);
}
System.Windows.Media.CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
}
public KinectD3DImage()
{
if (App.Current.MainWindow != null)
{
IntPtr window = new WindowInteropHelper(App.Current.MainWindow).Handle;
var presentparams = new SharpDX.Direct3D9.PresentParameters
{
Windowed = true,
SwapEffect = SharpDX.Direct3D9.SwapEffect.Discard,
DeviceWindowHandle = window,
PresentationInterval = PresentInterval.Immediate,
};
const CreateFlags deviceFlags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve;
this.direct3d = new Direct3DEx();
this.imagingFactory = new ImagingFactory();
this.device = Capture.Direct3D11Helper.CreateDevice();
this.d3dDevice = Capture.Direct3D11Helper.CreateSharpDXDevice(this.device);
this.d9device = new DeviceEx(this.direct3d, 0, DeviceType.Hardware, IntPtr.Zero, deviceFlags, presentparams);
this.IsFrontBufferAvailableChanged += this.GraphicItemD3DImageIsFrontBufferAvailableChanged;
this.renderEvent = new ManualResetEventSlim(false);
var renderThread = new Thread(this.RenderThread);
renderThread.Start();
}
}
/// <summary>
/// Constructor for the hooking class.
/// Creates the Direct3D9/Direct3D9Ex devices inside the function to get their
/// native pointer for hooking purposes.
/// </summary>
public DX9Hook()
{
// Obtain the pointer to the IDirect3DDevice9 instance
// by creating our own blank windows form and creating a IDirect3DDevice9
// targeting that form. The returned device should be the same one as used by the game.
using (Direct3D direct3D = new Direct3D())
using (Form renderForm = new Form())
using (Device device = new Device(direct3D, 0, DeviceType.NullReference, IntPtr.Zero, CreateFlags.HardwareVertexProcessing, new PresentParameters()
{
BackBufferWidth = 1, BackBufferHeight = 1, DeviceWindowHandle = renderForm.Handle
}))
{
DirectXFunctions = new VirtualFunctionTable(device.NativePointer, Enum.GetNames(typeof(Direct3DDevice9)).Length);
}
// Obtain the pointer to the IDirect3DDevice9Ex instance
// by creating our own blank windows form and creating a IDirect3DDevice9Ex
// targeting that form. The returned device should be the same one as used by the game.
using (Direct3DEx direct3D = new Direct3DEx())
using (var renderForm = new Form())
using (DeviceEx device = new DeviceEx(direct3D, 0, DeviceType.NullReference, IntPtr.Zero, CreateFlags.HardwareVertexProcessing, new PresentParameters()
{
BackBufferWidth = 1, BackBufferHeight = 1, DeviceWindowHandle = renderForm.Handle
}))
{
try
{
DirectXFunctions.TableEntries.AddRange(VirtualFunctionTable.GetObjectVTableAddresses(device.NativePointer, Enum.GetNames(typeof(Direct3DDevice9Ex)).Length));
SupportsDirect3D9Ex = true;
}
catch { SupportsDirect3D9Ex = false; }
}
}
void Initialise()
{
if (this.FHandle == (IntPtr)0)
{
throw (new Exception("No shared texture handle set"));
}
this.FContext = new Direct3DEx();
this.FHiddenControl = new Control();
this.FHiddenControl.Visible = false;
this.FHiddenControl.Width = this.FWidth;
this.FHiddenControl.Height = this.FHeight;
var flags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.PureDevice | CreateFlags.FpuPreserve;
this.FDevice = new DeviceEx(FContext, 0, DeviceType.Hardware, this.FHiddenControl.Handle, flags, new PresentParameters()
{
BackBufferWidth = this.FWidth,
BackBufferHeight = this.FHeight
});
this.FTextureShared = new Texture(this.FDevice, this.FWidth, this.FHeight, 1, FUsage, FFormat, Pool.Default, ref this.FHandle);
this.FTextureCopied = new Texture(this.FDevice, this.FWidth, this.FHeight, 1, Usage.RenderTarget, FFormat, Pool.Default);
var description = FTextureCopied.GetLevelDescription(0);
this.FSurfaceOffscreen = Surface.CreateOffscreenPlainEx(FDevice, FWidth, FHeight, description.Format, Pool.SystemMemory, Usage.None);
this.FInitialised = true;
}
public void StartDirect3D(Window window)
{
Direct3DContext = new Direct3DEx();
var presentParameters = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
DeviceWindowHandle = new WindowInteropHelper(window).Handle,
PresentationInterval = SharpDX.Direct3D9.PresentInterval.Default
};
Direct3DDevice = new DeviceEx(Direct3DContext, 0, DeviceType.Hardware, IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
presentParameters);
// Create the device using the main window handle, and a placeholder size (1,1).
// The actual size doesn't matter because whenever we render using this GraphicsDevice,
// we will make sure the back buffer is large enough for the window we're rendering into.
// Also, the handle doesn't matter because we call GraphicsDevice.Present(...) with the
// actual window handle to render into.
GraphicsDevice = CreateGraphicsDevice(new WindowInteropHelper(window).Handle, 1, 1);
DeviceCreated?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Creates a new instance of <see cref="SharpDXElement"/> class.
/// Initializes the D3D9 runtime.
/// </summary>
public SharpDXElement()
{
image = new D3DImage();
var presentparams = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
DeviceWindowHandle = GetDesktopWindow(),
PresentationInterval = PresentInterval.Default
};
direct3D = new Direct3DEx();
device9 = new DeviceEx(direct3D,
0,
DeviceType.Hardware,
IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
presentparams);
resizeDelayTimer = new DispatcherTimer(DispatcherPriority.Normal);
resizeDelayTimer.Interval = SendResizeDelay;
resizeDelayTimer.Tick += HandleResizeDelayTimerTick;
SizeChanged += HandleSizeChanged;
Unloaded += HandleUnloaded;
}
public Graphics(RenderForm form, int width, int height)
{
reset = () => form.Invoke(new Action(() =>
{
device.Reset(presentParameters);
fontRenderer.Flush();
textureRenderer.Flush();
resized = false;
}));
form.UserResized += (sender, args) => Resize(form.ClientSize.Width, form.ClientSize.Height);
presentParameters = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
BackBufferFormat = Format.A8R8G8B8,
BackBufferCount = 1,
BackBufferWidth = width,
BackBufferHeight = height,
PresentationInterval = PresentInterval.One,
MultiSampleType = MultisampleType.None,
MultiSampleQuality = 0,
PresentFlags = PresentFlags.LockableBackBuffer
};
direct3D = new Direct3DEx();
device = new DeviceEx(direct3D, 0, DeviceType.Hardware, form.Handle, CREATE_FLAGS, presentParameters);
fontRenderer = new FontRenderer(device);
textureRenderer = new TextureRenderer(device);
renderLocker.Reset();
}
void InitD3D9()
{
if (NumActiveImages == 0)
{
D3DContext = new Direct3DEx();
PresentParameters pp = new PresentParameters();
pp.Windowed = true;
pp.SwapEffect = SwapEffect.Discard;
pp.DeviceWindowHandle = GetDesktopWindow();
pp.PresentationInterval = PresentInterval.Immediate;
pp.Multisample = MultisampleType.None;
pp.MultisampleQuality = 0;
var format = Format.A8R8G8B8;
var adapter = 0;
// check for 4xAA
if (D3DContext.CheckDeviceMultisampleType(adapter, DeviceType.Hardware, format, true, MultisampleType.FourSamples))
{
pp.Multisample = MultisampleType.FourSamples;
}
// check fo 2xAA
else if (D3DContext.CheckDeviceMultisampleType(adapter, DeviceType.Hardware, format, true, MultisampleType.TwoSamples))
{
pp.Multisample = MultisampleType.TwoSamples;
}
D3DDevice = new DeviceEx(D3DContext, adapter, DeviceType.Hardware, IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, pp);
}
}
public static void Load()
{
if (_d3d == null)
{
_d3d = new Direct3DEx();
}
}
/// <summary>
///
/// </summary>
public D3D9()
{
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = true;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = D3D9.GetDesktopWindow();
presentparams.EnableAutoDepthStencil = false;
presentparams.AutoDepthStencilFormat = Format.D24S8;
presentparams.PresentationInterval = PresentInterval.Default;
try
{
using (Diagnostics.PotentialExceptionRegion)
{
var context = new Direct3DEx();
Context = context;
this._device = new DeviceEx(context, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
}
catch (Exception)
{
Context = new Direct3D();
this._device = new Device(Context, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
}
private void CleanUp()
{
logger.Verb("D3DImageRenderer::CleanUp()");
//System.Windows.Media.CompositionTarget.Rendering -= CompositionTarget_Rendering;
if (surface != null)
{
surface.Dispose();
surface = null;
}
if (direct3D != null)
{
direct3D.Dispose();
direct3D = null;
}
if (device != null)
{
device.Dispose();
device = null;
}
if (waitEvent != null)
{
waitEvent.Dispose();
waitEvent = null;
}
state = RendererState.Closed;
}
private void Initialize3D()
{
HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "D3", IntPtr.Zero);
pp.SwapEffect = SwapEffect.Discard;
pp.DeviceWindowHandle = hwnd.Handle;
pp.Windowed = true;
pp.BackBufferWidth = (int)ActualWidth;
pp.BackBufferHeight = (int)ActualHeight;
pp.BackBufferFormat = Format.X8R8G8B8;
try
{
var direct3DEx = new Direct3DEx();
direct3D = direct3DEx;
device = new DeviceEx(direct3DEx, 0, DeviceType.Hardware, hwnd.Handle, CreateFlags.HardwareVertexProcessing, pp);
}
catch
{
direct3D = new Direct3D();
device = new Device(direct3D, 0, DeviceType.Hardware, hwnd.Handle, CreateFlags.HardwareVertexProcessing, pp);
}
System.Windows.Media.CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
}
/// <summary>
/// Initializes a new instance of the <see cref="D3D9"/> class.
/// </summary>
public D3D9()
{
// Create Direct3DEx device on Windows Vista/7/8 with a display configured to use
// the Windows Display Driver Model (WDDM). Use Direct3D on any other platform.
_direct3D = new Direct3DEx();
PresentParameters presentparams = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
PresentationInterval = PresentInterval.Default,
// The device back buffer is not used.
BackBufferFormat = Format.Unknown,
BackBufferWidth = 1,
BackBufferHeight = 1,
// Use dummy window handle.
DeviceWindowHandle = GetDesktopWindow()
};
_device = new DeviceEx(_direct3D, 0, DeviceType.Hardware, IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
presentparams);
}
private void Initialize3D()
{
HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "D3", IntPtr.Zero);
_pp.SwapEffect = SwapEffect.Discard;
_pp.DeviceWindowHandle = hwnd.Handle;
_pp.Windowed = true;
_pp.EnableAutoDepthStencil = true;
_pp.BackBufferWidth = Math.Max(100, (int)ActualWidth);
_pp.BackBufferHeight = Math.Max(100, (int)ActualHeight);
_pp.BackBufferFormat = Format.A8R8G8B8;
_pp.AutoDepthStencilFormat = Format.D32SingleLockable;
_pp.BackBufferCount = 1;
try
{
var direct3DEx = new Direct3DEx();
Direct3D = direct3DEx;
Device = new DeviceEx(direct3DEx, 0, DeviceType.Hardware, hwnd.Handle, CreateFlags.HardwareVertexProcessing, _pp);
}
catch
{
// At this point we are pretty much screwed, require DeviceEx for the reset capability
MessageBox.Show("Can't start DirectX, so that pretty much discounts doing anything else");
}
System.Windows.Media.CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
}
public static void Unload()
{
if (_d3d != null)
{
_d3d.Dispose();
}
_d3d = null;
}
// - private methods -------------------------------------------------------------
private void StartD3D()
{
var presentParams = GetPresentParameters();
var createFlags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve;
D3DContext = new Direct3DEx();
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, createFlags, presentParams);
}
public GraphicsInteropImageSource()
{
var presentParams = GetPresentParameters();
var createFlags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve;
D3DContext = new Direct3DEx();
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, createFlags, presentParams);
}
public DwmCapture(IntPtr hWnd)
{
_captureHwnd = hWnd;
#region Initialise the Direct3D device
int adapterOrdinal = 0;
_d3dEx = new Direct3DEx();
_adapterLuid = _d3dEx.GetAdapterLuid(adapterOrdinal);
var presentParams = new PresentParameters
{
PresentFlags = PresentFlags.LockableBackBuffer,
Windowed = true,
BackBufferFormat = Format.A8R8G8B8,
SwapEffect = SwapEffect.Flip
};
_deviceEx = new DeviceEx(_d3dEx, adapterOrdinal, DeviceType.Hardware, _captureHwnd, SlimDX.Direct3D9.CreateFlags.Multithreaded | SlimDX.Direct3D9.CreateFlags.SoftwareVertexProcessing, presentParams);
#endregion
#region Setup the shared surface (using DWM)
uint format = 0;
IntPtr pSharedHandle = IntPtr.Zero;
int hr = NativeMethods.GetSharedSurface(_captureHwnd, _adapterLuid, 0, 0, ref format, out pSharedHandle, 0);
NativeMethods.UpdateWindowShared(_captureHwnd, 0, 0, 0, IntPtr.Zero, IntPtr.Zero);
RECT winRect;
NativeMethods.GetWindowRect(_captureHwnd, out winRect);
Size size = new Size(winRect.Right - winRect.Left, winRect.Bottom - winRect.Top);
/* Hack because SlimDX does not let you specify a shared handle for creating shared resources we
* have to create an IDirect3DDevice9 reference to the device instead */
IDirect3DDevice9 devEx = (IDirect3DDevice9)Marshal.GetObjectForIUnknown(_deviceEx.ComPointer);
IntPtr pTexture;
devEx.CreateTexture((int)size.Width, (int)size.Height, 1, 1, format, 0, out pTexture, ref pSharedHandle);
Texture texture = Texture.FromPointer(pTexture);
_sharedSurface = texture.GetSurfaceLevel(0);
_renderTarget = Surface.CreateRenderTarget(_deviceEx, (int)size.Width, (int)size.Height, Format.X8R8G8B8,
MultisampleType.None, 0, false);
_deviceEx.SetRenderTarget(0, _renderTarget);
Surface.FromSurface(_renderTarget, _sharedSurface, Filter.None, 0);
_systemMemorySurface = Surface.CreateOffscreenPlain(_deviceEx, (int)size.Width, (int)size.Height,
Format.X8R8G8B8, Pool.SystemMemory);
#endregion
}
public DwmCapture(IntPtr hWnd)
{
_captureHwnd = hWnd;
#region Initialise the Direct3D device
int adapterOrdinal = 0;
_d3dEx = new Direct3DEx();
_adapterLuid = _d3dEx.GetAdapterLuid(adapterOrdinal);
var presentParams = new PresentParameters
{
PresentFlags = PresentFlags.LockableBackBuffer,
Windowed = true,
BackBufferFormat = Format.A8R8G8B8,
SwapEffect = SwapEffect.Flip
};
_deviceEx = new DeviceEx(_d3dEx, adapterOrdinal, DeviceType.Hardware, _captureHwnd, SlimDX.Direct3D9.CreateFlags.Multithreaded | SlimDX.Direct3D9.CreateFlags.SoftwareVertexProcessing, presentParams);
#endregion
#region Setup the shared surface (using DWM)
uint format = 0;
IntPtr pSharedHandle = IntPtr.Zero;
int hr = NativeMethods.GetSharedSurface(_captureHwnd, _adapterLuid, 0, 0, ref format, out pSharedHandle, 0);
NativeMethods.UpdateWindowShared(_captureHwnd, 0, 0, 0, IntPtr.Zero, IntPtr.Zero);
RECT winRect;
NativeMethods.GetWindowRect(_captureHwnd, out winRect);
Size size = new Size(winRect.Right - winRect.Left, winRect.Bottom - winRect.Top);
/* Hack because SlimDX does not let you specify a shared handle for creating shared resources we
* have to create an IDirect3DDevice9 reference to the device instead */
IDirect3DDevice9 devEx = (IDirect3DDevice9)Marshal.GetObjectForIUnknown(_deviceEx.ComPointer);
IntPtr pTexture;
devEx.CreateTexture((int)size.Width, (int)size.Height, 1, 1, format, 0, out pTexture, ref pSharedHandle);
Texture texture = Texture.FromPointer(pTexture);
_sharedSurface = texture.GetSurfaceLevel(0);
_renderTarget = Surface.CreateRenderTarget(_deviceEx, (int)size.Width, (int)size.Height, Format.X8R8G8B8,
MultisampleType.None, 0, false);
_deviceEx.SetRenderTarget(0, _renderTarget);
Surface.FromSurface(_renderTarget, _sharedSurface, Filter.None, 0);
_systemMemorySurface = Surface.CreateOffscreenPlain(_deviceEx, (int)size.Width, (int)size.Height,
Format.X8R8G8B8, Pool.SystemMemory);
#endregion
}
// - private methods -------------------------------------------------------------
private void StartD3D()
{
if (ActiveClients != 0)
{
return;
}
D3DContext = new Direct3DEx();
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, GetPresentParameters());
}
internal static void EnsureD3D9()
{
if (Direct3D9Object == null)
#if TEST_Direct3D9Ex
{ Direct3D9Object = new Direct3DEx(); // yyagi
}
#else
{ Direct3D9Object = new Direct3D(); }
#endif
}
// - private methods -------------------------------------------------------------
private void StartD3D()
{
if (Dx11ImageSource.ActiveClients != 0)
{
return;
}
var presentParams = GetPresentParameters();
var createFlags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve;
Dx11ImageSource.D3DContext = new Direct3DEx();
Dx11ImageSource.D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, createFlags, presentParams);
}
void InitializeDirect3D()
{
try
{
direct3DEx = new Direct3DEx();
useDeviceEx = true;
}
catch
{
direct3D = new Direct3D();
useDeviceEx = false;
}
}
private static void StartD3D()
{
_d3DContext = new Direct3DEx();
var presentparams = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
DeviceWindowHandle = GetDesktopWindow(),
PresentationInterval = PresentInterval.Default
};
D3D10ImageSource._d3DDevice = new DeviceEx(_d3DContext, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
private void ReleaseDirect3D()
{
if (_direct3D != null && !_direct3D.Disposed)
{
_direct3D.Dispose();
_direct3D = null;
}
if (_direct3DEx != null && !_direct3DEx.Disposed)
{
_direct3DEx.Dispose();
_direct3DEx = null;
}
}
public D3D9()
{
var presentparams = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
DeviceWindowHandle = GetDesktopWindow(),
PresentationInterval = PresentInterval.Default
};
const CreateFlags deviceFlags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve;
direct3d = new Direct3DEx();
device = new DeviceEx(direct3d, 0, DeviceType.Hardware, IntPtr.Zero, deviceFlags, presentparams);
}
private static void StartD3D()
{
if (_activeClients != 0)
{
return;
}
var presentParams = GetPresentParameters();
const CreateFlags createFlags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded |
CreateFlags.FpuPreserve;
_d3DContext = new Direct3DEx();
_d3DDevice =
new DeviceEx(_d3DContext, 0, DeviceType.Hardware, IntPtr.Zero, createFlags, presentParams);
}
void InitD3D9()
{
if (NumActiveImages == 0)
{
D3DContext = new Direct3DEx();
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = true;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = GetDesktopWindow();
presentparams.PresentationInterval = PresentInterval.Immediate;
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
}
private void StartD3D()
{
context = new Direct3DEx();
// Ref: https://docs.microsoft.com/en-us/dotnet/framework/wpf/advanced/wpf-and-direct3d9-interoperation
var presentparams = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
//DeviceWindowHandle = GetDesktopWindow(),
PresentationInterval = PresentInterval.Default,
BackBufferHeight = 1, BackBufferWidth = 1, BackBufferFormat = Format.Unknown
};
device = new DeviceEx(context, this.adapterIndex, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
public D3D9(DeviceEx device)
{
if (device != null)
{
throw new NotSupportedException();
}
else
{
context = new Direct3DEx();
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = true;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = GetDesktopWindow();
presentparams.PresentationInterval = PresentInterval.Default;
this.device = new DeviceEx(context, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
}
private void StartD3D()
{
if (DX10ImageSource.ActiveClients != 0)
{
return;
}
D3DContext = new Direct3DEx();
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = true;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = GetDesktopWindow();
presentparams.PresentationInterval = PresentInterval.Default;
DX10ImageSource.D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
/// <summary>
/// 必要ありそうなら、DirectX9を初期化する。(WPF用)
/// </summary>
private void InitD3D9()
{
if (ActiveImageCount == 0)
{
D3DContext = new Direct3DEx();
var presentParam = new PresentParameters();
presentParam.Windowed = true;
presentParam.SwapEffect = SwapEffect.Discard;
presentParam.DeviceWindowHandle = GetDesktopWindow();
presentParam.PresentationInterval = PresentInterval.Immediate;
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
presentParam);
D3DDevice.SetRenderState(RenderState.AlphaBlendEnable, false);
}
}
public Scene(Control _control, Device _device)
{
m_Control = _control;
m_Device = _device;
if (m_Device == null)
{
Direct3DEx _d3d = new Direct3DEx();
DisplayMode _mode = _d3d.GetAdapterDisplayMode(0);
PresentParameters _parameters = new PresentParameters();
_parameters.BackBufferFormat = _mode.Format;
_parameters.BackBufferCount = 1;
_parameters.BackBufferWidth = m_Control.Width;
_parameters.BackBufferHeight = m_Control.Height;
_parameters.Multisample = MultisampleType.None;
_parameters.SwapEffect = SwapEffect.Discard;
_parameters.PresentationInterval = PresentInterval.Default;
_parameters.Windowed = true;
_parameters.DeviceWindowHandle = m_Control.Handle;
_parameters.PresentFlags = PresentFlags.DeviceClip | PresentFlags.Video;
m_Device = new DeviceEx(_d3d, 0, DeviceType.Hardware, m_Control.Handle, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, _parameters);
m_RenderTarget = m_Device.GetRenderTarget(0);
}
}
public static void Unload()
{
if (_d3d != null)
_d3d.Dispose();
_d3d = null;
}
public static void Load()
{
if (_d3d == null)
_d3d = new Direct3DEx();
}
private void InitializeD3D()
{
// Create the D3D object.
d3d = new Direct3DEx();
PresentParameters pp = new PresentParameters();
pp.BackBufferWidth = 512;
pp.BackBufferHeight = 512;
pp.BackBufferFormat = Format.Unknown;
pp.BackBufferCount = 0;
pp.Multisample = MultisampleType.None;
pp.MultisampleQuality = 0;
pp.SwapEffect = SwapEffect.Discard;
pp.DeviceWindowHandle = panel1.Handle;
pp.Windowed = true;
pp.EnableAutoDepthStencil = false;
pp.AutoDepthStencilFormat = Format.Unknown;
pp.PresentationInterval = PresentInterval.Default;
bDeviceFound = false;
CUdevice[] cudaDevices = null;
for (g_iAdapter = 0; g_iAdapter < d3d.AdapterCount; g_iAdapter++)
{
device = new DeviceEx(d3d, d3d.Adapters[g_iAdapter].Adapter, DeviceType.Hardware, panel1.Handle, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded, pp);
try
{
cudaDevices = CudaContext.GetDirectXDevices(device.ComPointer, CUd3dXDeviceList.All, CudaContext.DirectXVersion.D3D9);
bDeviceFound = cudaDevices.Length > 0;
Console.WriteLine("> Display Device #" + d3d.Adapters[g_iAdapter].Adapter
+ ": \"" + d3d.Adapters[g_iAdapter].Details.Description + "\" supports Direct3D9 and CUDA.");
break;
}
catch (CudaException)
{
//No Cuda device found for this Direct3D9 device
Console.WriteLine("> Display Device #" + d3d.Adapters[g_iAdapter].Adapter
+ ": \"" + d3d.Adapters[g_iAdapter].Details.Description + "\" supports Direct3D9 but not CUDA.");
}
}
// we check to make sure we have found a cuda-compatible D3D device to work on
if (!bDeviceFound)
{
Console.WriteLine("No CUDA-compatible Direct3D9 device available");
if (device != null)
device.Dispose();
Close();
return;
}
ctx = new CudaContext(cudaDevices[0], device.ComPointer, CUCtxFlags.BlockingSync, CudaContext.DirectXVersion.D3D9);
// Set projection matrix
SlimDX.Matrix matProj = SlimDX.Matrix.OrthoOffCenterLH(0, 1, 1, 0, 0, 1);
device.SetTransform(TransformState.Projection, matProj);
// Turn off D3D lighting, since we are providing our own vertex colors
device.SetRenderState(RenderState.Lighting, false);
//Load kernels
CUmodule module = ctx.LoadModulePTX("kernel.ptx");
addForces_k = new CudaKernel("addForces_k", module, ctx);
advectVelocity_k = new CudaKernel("advectVelocity_k", module, ctx);
diffuseProject_k = new CudaKernel("diffuseProject_k", module, ctx);
updateVelocity_k = new CudaKernel("updateVelocity_k", module, ctx);
advectParticles_k = new CudaKernel("advectParticles_k", module, ctx);
}
public Renderer(Control _control, bool _fullscreen, String _renderMethod)
{
fullscreen = _fullscreen;
m_Control = _control;
renderMethod = _renderMethod;
if (m_Device == null)
{
Direct3DEx _d3d = new Direct3DEx();
PresentParameters _parameters = new PresentParameters();
if (fullscreen)
{
_parameters.BackBufferWidth = 1920;// m_Control.Width;
_parameters.BackBufferHeight = 1080;// m_Control.Height;
}
else
{
_parameters.BackBufferWidth = 1280;// m_Control.Width;
_parameters.BackBufferHeight = 800;// m_Control.Height;
}
if (fullscreen)
{
_parameters.BackBufferFormat = Format.X8R8G8B8;
_parameters.BackBufferCount = 1;
_parameters.Multisample = MultisampleType.None;
_parameters.SwapEffect = SwapEffect.Flip;
//_parameters.PresentationInterval = PresentInterval.Default;
_parameters.PresentationInterval = PresentInterval.Immediate;
_parameters.Windowed = false;
_parameters.DeviceWindowHandle = m_Control.Parent.Handle;
_parameters.SwapEffect = SwapEffect.Flip;
_parameters.FullScreenRefreshRateInHertz = 0;
_parameters.PresentFlags = PresentFlags.None | PresentFlags.DiscardDepthStencil;
_parameters.AutoDepthStencilFormat = Format.D24X8;
_parameters.EnableAutoDepthStencil = true;
m_Device = new Device(_d3d, 0, DeviceType.Hardware, m_Control.Parent.Handle, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, _parameters);
}
else
{
DisplayMode _mode = _d3d.GetAdapterDisplayMode(0);
_parameters.BackBufferFormat = _mode.Format;
_parameters.BackBufferCount = 1;
_parameters.Multisample = MultisampleType.None;
_parameters.SwapEffect = SwapEffect.Flip;
_parameters.PresentationInterval = PresentInterval.Default;
_parameters.Windowed = true;
_parameters.DeviceWindowHandle = m_Control.Handle;
_parameters.PresentationInterval = PresentInterval.Immediate;
_parameters.PresentFlags = PresentFlags.DeviceClip | PresentFlags.Video;
m_Device = new DeviceEx(_d3d, 0, DeviceType.Hardware, m_Control.Handle, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, _parameters);
}
}
m_RenderTarget = m_Device.GetRenderTarget(0);
leftTex = new Texture(m_Device, 1280, 720, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
//leftTex = Texture.FromFile(m_Device, ".\\Images\\checkerboard.jpg", D3DX.DefaultNonPowerOf2, D3DX.DefaultNonPowerOf2, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default, Filter.None, Filter.None, 0);
//leftTex = Texture.FromFile(m_Device, ".\\Images\\LeftEye.jpg", D3DX.DefaultNonPowerOf2, D3DX.DefaultNonPowerOf2, 1, Usage.RenderTarget, Format.Unknown, Pool.Default, Filter.None, Filter.None, 0);
SurfaceDescription desc = leftTex.GetLevelDescription(0);
//leftTex = Texture.FromFile(m_Device, ".\\Images\\CheckerboardLeft.jpg", Usage.RenderTarget, Pool.Default);
rightTex = new Texture(m_Device, 1280, 720, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
//rightTex = Texture.FromFile(m_Device, ".\\Images\\RightEye.jpg", D3DX.DefaultNonPowerOf2, D3DX.DefaultNonPowerOf2, 1, Usage.RenderTarget, Format.Unknown, Pool.Default, Filter.None, Filter.None, 0);
//rightTex = Texture.FromFile(m_Device, ".\\Images\\CheckerboardRight.jpg", Usage.RenderTarget, Pool.Default);
m_font = new SlimDX.Direct3D9.Font(m_Device, new System.Drawing.Font(FontFamily.GenericSansSerif, 24.0f));
switch (renderMethod)
{
case "None" :
m_distortionEffect = Effect.FromFile(m_Device, "PlainPS.fx", ShaderFlags.None);
break;
case "Oculus":
m_distortionEffect = Effect.FromFile(m_Device, "OculusRiftPS.fx", ShaderFlags.None);
break;
case "3DTV":
m_distortionEffect = Effect.FromFile(m_Device, "PlainPS.fx", ShaderFlags.None);
break;
default:
throw new Exception("No render method found.");
break;
}
//leftImage = Surface.CreateOffscreenPlain(m_Device, 640, 720, Format.A8R8G8B8, Pool.Default);
//Surface.FromFile(leftImage, ".\\Images\\checkerboardRedGreen.jpg", Filter.None, 0);
//rightImage = Surface.CreateOffscreenPlain(m_Device, 640, 720, Format.A8R8G8B8, Pool.Default);
//Surface.FromFile(rightImage, ".\\Images\\checkerboardRedGreen.jpg", Filter.None, 0);
//tex = new Texture(m_Device, 1280, 720, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
//tex = new Texture(m_Device, 1280, 720, 1, Usage.RenderTarget, Format.R8G8B8, Pool.Default);
}
private void StartD3D()
{
if (activeClients != 0)
return;
context = new Direct3DEx();
var presentparams = new PresentParameters
{
Windowed = true,
SwapEffect = SwapEffect.Discard,
DeviceWindowHandle = GetDesktopWindow(),
PresentationInterval = PresentInterval.Default,
};
device = new DeviceEx(context, this.adapterIndex, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
private void StartD3D()
{
if (DX11ImageSource.ActiveClients != 0)
return;
D3DContext = new Direct3DEx();
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = true;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = GetDesktopWindow();
presentparams.PresentationInterval = PresentInterval.Default;
DX11ImageSource.D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
/// <summary>
/// Initializes Direct3D9 and creates a static D3D9 device for interop
/// </summary>
private static void CreateDevice()
{
m_direct3D = new Direct3DEx();
/* Create the device present parameters */
var param = new PresentParameters();
param.Windowed = true;
param.SwapEffect = SwapEffect.Discard;
param.BackBufferFormat = Format.A8R8G8B8;
param.PresentationInterval = PresentInterval.Immediate;
/* Creates the Direct3D9Ex device. This must be an "Ex" device
* to allow resource sharing with D3D10 */
m_device = new DeviceEx(m_direct3D,
0,
DeviceType.Hardware,
GetDesktopWindow(),
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
param);
}
public Scene(Control _control, Device _device, int adapterId, bool fullScreen)
{
m_Control = _control;
m_Device = _device;
m_fullscreen = fullScreen;
m_adapterId = adapterId;
if (m_Device == null)
{
Direct3DEx _d3d = new Direct3DEx();
PresentParameters _parameters = new PresentParameters();
_parameters.BackBufferWidth = 1280;// m_Control.Width;
_parameters.BackBufferHeight = 800;// m_Control.Height;
_parameters.BackBufferWidth = 1920;// m_Control.Width;
_parameters.BackBufferHeight = 1080;// m_Control.Height;
if (m_fullscreen)
{
_parameters.BackBufferFormat = Format.X8R8G8B8;
_parameters.BackBufferCount = 1;
_parameters.Multisample = MultisampleType.None;
_parameters.SwapEffect = SwapEffect.Flip;
_parameters.PresentationInterval = PresentInterval.Default;
_parameters.Windowed = false;
_parameters.DeviceWindowHandle = m_Control.Parent.Handle;
_parameters.SwapEffect = SwapEffect.Flip;
_parameters.PresentationInterval = PresentInterval.Immediate;
_parameters.FullScreenRefreshRateInHertz = 0;
_parameters.PresentFlags = PresentFlags.None | PresentFlags.DiscardDepthStencil;
_parameters.AutoDepthStencilFormat = Format.D24X8;
_parameters.EnableAutoDepthStencil = true;
m_Device = new Device(_d3d, m_adapterId, DeviceType.Hardware, m_Control.Parent.Handle, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, _parameters);
}
else
{
DisplayMode _mode = _d3d.GetAdapterDisplayMode(0);
_parameters.BackBufferFormat = _mode.Format;
_parameters.BackBufferCount = 1;
_parameters.Multisample = MultisampleType.None;
_parameters.SwapEffect = SwapEffect.Discard;
_parameters.PresentationInterval = PresentInterval.Default;
_parameters.Windowed = true;
_parameters.DeviceWindowHandle = m_Control.Handle;
_parameters.PresentFlags = PresentFlags.DeviceClip | PresentFlags.Video;
m_Device = new DeviceEx(_d3d, m_adapterId, DeviceType.Hardware, m_Control.Handle, CreateFlags.Multithreaded | CreateFlags.HardwareVertexProcessing, _parameters);
}
}
m_RenderTarget = m_Device.GetRenderTarget(0);
m_tex = new Texture(m_Device, 1280, 800, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
m_font = new SlimDX.Direct3D9.Font(m_Device, new System.Drawing.Font(FontFamily.GenericSansSerif, 24.0f));
m_distortionEffect = Effect.FromFile(m_Device, "OculusRift.fx", ShaderFlags.None);
RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey("Software", true);
RegistryKey scottCutlerKey = softwareKey.CreateSubKey("Scott Cutler");
RegistryKey ocucamKey = scottCutlerKey.CreateSubKey("Ocucam");
//Begin fix code
ocucamKey.SetValue("pupilOffset", m_pupilOffset);
ocucamKey.SetValue("scale", m_scale);
//End fix code
m_pupilOffset = Convert.ToSingle((string)ocucamKey.GetValue("pupilOffset", m_pupilOffset));
m_scale = Convert.ToSingle((string)ocucamKey.GetValue("scale", m_scale));
ocucamKey.Close();
scottCutlerKey.Close();
softwareKey.Close();
}
void ShutdownD3D9()
{
if (NumActiveImages == 0)
{
if (SharedTexture != null)
{
SharedTexture.Dispose();
SharedTexture = null;
}
if (D3DDevice != null)
{
D3DDevice.Dispose();
D3DDevice = null;
}
if (D3DContext != null)
{
D3DContext.Dispose();
D3DContext = null;
}
}
}
void InitD3D9()
{
if (NumActiveImages == 0)
{
D3DContext = new Direct3DEx();
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = true;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = GetDesktopWindow();
presentparams.PresentationInterval = PresentInterval.Immediate;
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve, presentparams);
}
}
public Device(IntPtr handle, int width, int height)
{
if (handle == IntPtr.Zero)
throw new ArgumentException("Value must be a valid window handle", "handle");
if (GetSystemMetrics(SM_REMOTESESSION) != 0)
throw new Exception("We can't run at all under terminal services");
int renderingTier = (RenderCapability.Tier >> 16);
if (renderingTier < 2)
throw new Exception("Render capability check failed, low tier=" + renderingTier);
// Create D3D
try
{
this.direct3dEx = new Direct3DEx();
UseDeviceEx = true;
}
catch
{
this.direct3d = new Direct3D();
UseDeviceEx = false;
}
// Create device
Result result;
if (!Direct3D.CheckDeviceType(0, DeviceType.Hardware, this.adapterFormat, this.backbufferFormat, true, out result))
throw new Exception("CheckDeviceType failed: " + result.ToString());
if (!Direct3D.CheckDepthStencilMatch(0, DeviceType.Hardware, this.adapterFormat, this.backbufferFormat, this.depthStencilFormat, out result))
throw new Exception("CheckDepthStencilMatch failed: " + result.ToString());
Capabilities deviceCaps = Direct3D.GetDeviceCaps(0, DeviceType.Hardware);
if ((deviceCaps.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
this.createFlags |= CreateFlags.HardwareVertexProcessing;
else
this.createFlags |= CreateFlags.SoftwareVertexProcessing;
PresentParams = new PresentParameters()
{
BackBufferFormat = this.backbufferFormat,
BackBufferCount = 1,
BackBufferWidth = width,
BackBufferHeight = height,
Multisample = MultisampleType.None,
SwapEffect = SwapEffect.Discard,
EnableAutoDepthStencil = true,
AutoDepthStencilFormat = this.depthStencilFormat,
PresentFlags = PresentFlags.DiscardDepthStencil,
PresentationInterval = PresentInterval.Immediate,
Windowed = true,
DeviceWindowHandle = handle,
};
if (UseDeviceEx)
{
this.deviceEx = new DeviceEx(this.direct3dEx,
0,
DeviceType.Hardware,
handle,
this.createFlags,
PresentParams);
}
else
{
this.device = new SlimDX.Direct3D9.Device(this.direct3d,
0,
DeviceType.Hardware,
handle,
this.createFlags,
PresentParams);
}
// Create vertex declarations
TransformedColoredVertexDecl = new TransformedColoredVertexDecl(this);
MeshVertexDecl = new MeshVertexDecl(this);
TextureVertexDecl = new TexturedVertexDecl(this);
ScreenVertexDecl = new ScreenVertexDecl(this);
ScreenVertexBuffer = new VertexBuffer<ScreenVertex>(this);
var vertices = new ScreenVertex[]
{
new ScreenVertex() { Position = new Vector3(-1.0f, -1.0f, 0.5f), UV = new Vector2(0.0f, 1.0f) },
new ScreenVertex() { Position = new Vector3(-1.0f, 1.0f, 0.5f), UV = new Vector2(0.0f, 0.0f) },
new ScreenVertex() { Position = new Vector3(1.0f, -1.0f, 0.5f), UV = new Vector2(1.0f, 1.0f) },
new ScreenVertex() { Position = new Vector3(1.0f, 1.0f, 0.5f), UV = new Vector2(1.0f, 0.0f) },
};
ScreenVertexBuffer.Write(vertices);
}
void InitD3D9()
{
if (NumActiveImages == 0)
{
D3DContext = new Direct3DEx();
PresentParameters presentparams = new PresentParameters();
presentparams.Windowed = settings.IsWindowed;
presentparams.SwapEffect = SwapEffect.Discard;
presentparams.DeviceWindowHandle = GetDesktopWindow();
presentparams.PresentationInterval = PresentInterval.Immediate;
if (!settings.IsWindowed)
{
presentparams.FullScreenRefreshRateInHertz = 120;
presentparams.BackBufferHeight = settings.ScreenHeight;
presentparams.BackBufferWidth = settings.ScreenWidth;
presentparams.BackBufferFormat = TranslateFormat(settings.Format);
DisplayModeEx fullScreen = new DisplayModeEx()
{
Format = TranslateFormat(settings.Format),
Width = settings.ScreenWidth,
Height = settings.ScreenHeight,
RefreshRate = 120
};
D3DDevice = new DeviceEx(D3DContext,
0, DeviceType.Hardware, IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
presentparams, fullScreen);
}
else
D3DDevice = new DeviceEx(D3DContext, 0, DeviceType.Hardware, IntPtr.Zero,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
presentparams);
}
}
private void InitDevice()
{
// Use D3DEx for Vista/Win7+
_is3D9Ex = false;
if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)
{
_is3D9Ex = true;
}
DeviceType devType = DeviceType.Hardware;
int adapterOrdinal = 0;
Direct3D d3d = null;
Direct3DEx d3dex = null;
if (_is3D9Ex)
{
try
{
// Create Ex, fallback if it fails
d3dex = new Direct3DEx();
}
catch
{
d3d = new Direct3D();
_is3D9Ex = false;
}
}
else
d3d = new Direct3D();
// Look for PerfHUD
AdapterCollection adapters = (_is3D9Ex ? d3dex : d3d).Adapters;
foreach (AdapterInformation adap in adapters)
{
if (adap.Details.Description.Contains("PerfH"))
{
adapterOrdinal = adap.Adapter;
devType = DeviceType.Reference;
}
}
foreach (var item in adapters[adapterOrdinal].GetDisplayModes(Format.X8R8G8B8))
{
string val = item.Width + "x" + item.Height;
bool found = false;
for (int i = 0; i < ValidResolutions.Count; i++)
{
if (ValidResolutions[i].Equals(val))
{
found = true;
break;
}
}
if(!found)
ValidResolutions.Add(val);
}
// Get resolution
Size res = GetResolution();
RenderSize = res;
form.ClientSize = res;
// Set present parameters
_pp = new PresentParameters();
_pp.Windowed = r_fs.Integer==0?true:false;
_pp.SwapEffect = SwapEffect.Discard;
_pp.EnableAutoDepthStencil = true;
_pp.AutoDepthStencilFormat = Format.D24S8;
_pp.PresentationInterval = (r_vsync.Integer==1? PresentInterval.One: PresentInterval.Immediate);
_pp.Multisample = MultiSampling;
_pp.BackBufferWidth = RenderSize.Width;
_pp.BackBufferHeight = RenderSize.Height;
_pp.BackBufferFormat = Format.X8R8G8B8;
_pp.DeviceWindowHandle = form.Handle;
// Handle Capabilities
Capabilities caps = adapters[adapterOrdinal].GetCaps(devType);
CreateFlags createFlags = CreateFlags.SoftwareVertexProcessing;
// Got hardare vertex?
if ((caps.DeviceCaps & DeviceCaps.HWTransformAndLight) == DeviceCaps.HWTransformAndLight)
{
createFlags = CreateFlags.HardwareVertexProcessing;
// Support pure device?
if ((caps.DeviceCaps & DeviceCaps.PureDevice) == DeviceCaps.PureDevice)
createFlags |= CreateFlags.PureDevice;
}
createFlags |= CreateFlags.FpuPreserve;
// Create d3d device + behemoth fallback
try
{
if (_is3D9Ex)
{
if (r_fs.Bool)
{
DisplayModeEx dsp = new DisplayModeEx();
dsp.Width = _pp.BackBufferWidth;
dsp.Height = _pp.BackBufferHeight;
dsp.Format = _pp.BackBufferFormat;
dsp.RefreshRate = 60;
_pp.FullScreenRefreshRateInHertz = 60;
//DisplayModeEx dispMode = d3dex.GetAdapterDisplayModeEx(adapterOrdinal);
//RenderSize = new Size(dispMode.Width, dispMode.Height);
//form.ClientSize = new Size(dispMode.Width, dispMode.Height);
//_pp.BackBufferFormat = dispMode.Format;
//_pp.BackBufferWidth = dispMode.Width;
//_pp.BackBufferHeight = dispMode.Height;
//_pp.FullScreenRefreshRateInHertz = dispMode.RefreshRate;
device = new DeviceEx(d3dex, adapterOrdinal, devType, form.Handle, createFlags, _pp, dsp);
}
else
device = new DeviceEx(d3dex, adapterOrdinal, devType, form.Handle, createFlags, _pp);
}
else
device = new Device(d3d, adapterOrdinal, devType, form.Handle, createFlags, _pp);
}
catch (Direct3D9Exception ex)
{
if (ex.ResultCode == ResultCode.NotAvailable)
{
// Try again with different settings
RenderSize = new Size(800, 600);
form.ClientSize = new Size(800, 600);
_pp.BackBufferWidth = 800;
_pp.BackBufferHeight = 600;
_pp.BackBufferCount = 1;
_pp.SwapEffect = SwapEffect.Discard;
createFlags &= ~(CreateFlags.PureDevice | CreateFlags.HardwareVertexProcessing);
createFlags |= CreateFlags.SoftwareVertexProcessing;
try
{
if (_is3D9Ex)
{
if (r_fs.Bool)
{
DisplayModeEx dispMode = d3dex.GetAdapterDisplayModeEx(adapterOrdinal);
RenderSize = new Size(dispMode.Width, dispMode.Height);
form.ClientSize = new Size(dispMode.Width, dispMode.Height);
_pp.BackBufferFormat = dispMode.Format;
_pp.BackBufferWidth = dispMode.Width;
_pp.BackBufferHeight = dispMode.Height;
_pp.FullScreenRefreshRateInHertz = dispMode.RefreshRate;
device = new DeviceEx(d3dex, adapterOrdinal, devType, form.Handle, createFlags, _pp, dispMode);
}
else
device = new DeviceEx(d3dex, adapterOrdinal, devType, form.Handle, createFlags, _pp);
}
else
device = new Device(d3d, adapterOrdinal, devType, form.Handle, createFlags, _pp);
}
catch (Exception ex2)
{
if (_is3D9Ex)
{
// 3. fallback.. disable ex
_is3D9Ex = false;
Size ress = GetResolution();
RenderSize = ress;
form.ClientSize = ress;
_pp.BackBufferWidth = ress.Width;
_pp.BackBufferHeight = ress.Height;
_pp.BackBufferCount = 1;
_pp.SwapEffect = SwapEffect.Discard;
d3dex.Dispose();
device = new Device(new Direct3D(), adapterOrdinal, devType, form.Handle, createFlags, _pp);
}
else
throw ex2;
}
}
else
throw ex;
}
// Load main shader
if (System.IO.File.Exists(System.Windows.Forms.Application.StartupPath+"/client/render/simple.fx"))
{
string shaderOutput = null;
SlimDX.Configuration.ThrowOnError = false;
effect = Effect.FromFile(device, System.Windows.Forms.Application.StartupPath + "/client/render/simple.fx", null, null, null, ShaderFlags.None, null, out shaderOutput);
if (shaderOutput != null && shaderOutput != "" && effect == null)
{
// Shader problem :..(
System.Windows.Forms.MessageBox.Show(shaderOutput, "Shader Compilation error :(", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
Shutdown();
return;
}
SlimDX.Configuration.ThrowOnError = true;
}
else
{
System.Console.WriteLine("Could not find shader..");
}
// Add fonts
if (Fonts.Count == 0)
{
System.Drawing.Text.PrivateFontCollection col = new System.Drawing.Text.PrivateFontCollection();
col.AddFontFile(System.Windows.Forms.Application.StartupPath + @"\data\gui\Candara.ttf");
// UI Title
System.Drawing.Font localFont = new System.Drawing.Font(col.Families[0], 10.5f, System.Drawing.FontStyle.Regular);
SlimDX.Direct3D9.Font font = new SlimDX.Direct3D9.Font(Renderer.Instance.device, localFont);
Fonts.Add("title", font);
// FPS, etc.
font = new SlimDX.Direct3D9.Font(device, new System.Drawing.Font("Lucidia Console", 10f, System.Drawing.FontStyle.Regular));
Fonts.Add("diag", font);
// Labels and UI elements
localFont = new System.Drawing.Font(col.Families[0], 10f, System.Drawing.FontStyle.Regular);
font = new SlimDX.Direct3D9.Font(Renderer.Instance.device, localFont);
Fonts.Add("label", font);
localFont = new System.Drawing.Font(col.Families[0], 15f, System.Drawing.FontStyle.Regular);
font = new SlimDX.Direct3D9.Font(Renderer.Instance.device, localFont);
Fonts.Add("biglabel", font);
localFont = new System.Drawing.Font(col.Families[0], 23f, System.Drawing.FontStyle.Regular);
font = new SlimDX.Direct3D9.Font(Renderer.Instance.device, localFont);
Fonts.Add("biggerlabel", font);
// Textbox
col = new System.Drawing.Text.PrivateFontCollection();
col.AddFontFile(System.Windows.Forms.Application.StartupPath + @"\data\gui\dina10px.ttf");
localFont = new System.Drawing.Font(col.Families[0], 12f, FontStyle.Regular);
font = new SlimDX.Direct3D9.Font(Renderer.Instance.device, localFont);
Fonts.Add("textbox", font);
}
// Init backbuffers, etc.
OnResetDevice();
bloom = new Bloom(this);
tonemap = new ToneMap(this);
// Init windowing system
WindowManager.Instance.Init(device);
}
public void Dispose()
{
Deallocate();
FContext.Dispose();
FContext = null;
}
void InitializeDirect3D()
{
try
{
direct3DEx = new Direct3DEx();
useDeviceEx = true;
}
catch
{
direct3D = new Direct3D();
useDeviceEx = false;
}
}
public Instance()
{
this.FContext = new Direct3DEx();
this.FHiddenControl = new Control();
}
/// <summary>
/// Initializes the Direct3D objects and sets the Available flag
/// </summary>
private void InitializeDirect3D()
{
DirectXStatus = DirectXStatus.Unavailable_Unknown;
ReleaseDevice();
ReleaseDirect3D();
// assume that we can't run at all under terminal services
//if (GetSystemMetrics(SM_REMOTESESSION) != 0)
//{
// DirectXStatus = DirectXStatus.Unavailable_RemoteSession;
// return;
//}
//int renderingTier = (RenderCapability.Tier >> 16);
//if (renderingTier < 2)
//{
//DirectXStatus = DirectXStatus.Unavailable_LowTier;
//return;
//}
#if USE_XP_MODE
_direct3D = new Direct3D();
UseDeviceEx = false;
#else
try
{
direct3DEx = new Direct3DEx();
UseDeviceEx = true;
}
catch
{
try
{
direct3D = new Direct3D();
UseDeviceEx = false;
}
catch (Direct3DX9NotFoundException)
{
DirectXStatus = DirectXStatus.Unavailable_MissingDirectX;
return;
}
catch
{
DirectXStatus = DirectXStatus.Unavailable_Unknown;
return;
}
}
#endif
bool ok;
Result result;
ok = Direct3D.CheckDeviceType(0, DeviceType.Hardware, adapterFormat, backbufferFormat, true, out result);
if (!ok)
{
//const int D3DERR_NOTAVAILABLE = -2005530518;
//if (result.Code == D3DERR_NOTAVAILABLE)
//{
// ReleaseDirect3D();
// Available = Status.Unavailable_NotReady;
// return;
//}
ReleaseDirect3D();
return;
}
ok = Direct3D.CheckDepthStencilMatch(0, DeviceType.Hardware, adapterFormat, backbufferFormat, depthStencilFormat, out result);
if (!ok)
{
ReleaseDirect3D();
return;
}
Capabilities deviceCaps = Direct3D.GetDeviceCaps(0, DeviceType.Hardware);
if ((deviceCaps.DeviceCaps & DeviceCaps.HWTransformAndLight) != 0)
createFlags |= CreateFlags.HardwareVertexProcessing;
else
createFlags |= CreateFlags.SoftwareVertexProcessing;
DirectXStatus = DirectXStatus.Available;
return;
}
private bool InitializeD3D()
{
HwndSource hwnd = new HwndSource(0, 0, 0, 0, 0, "null", IntPtr.Zero);
// Create the D3D object.
d3d = new Direct3DEx();
PresentParameters pp = new PresentParameters();
pp.BackBufferWidth = 512;
pp.BackBufferHeight = 512;
pp.BackBufferFormat = Format.Unknown;
pp.BackBufferCount = 0;
pp.Multisample = MultisampleType.None;
pp.MultisampleQuality = 0;
pp.SwapEffect = SwapEffect.Discard;
pp.DeviceWindowHandle = (IntPtr)0;
pp.Windowed = true;
pp.EnableAutoDepthStencil = false;
pp.AutoDepthStencilFormat = Format.Unknown;
pp.PresentationInterval = PresentInterval.Default;
bDeviceFound = false;
CUdevice[] cudaDevices = null;
for (g_iAdapter = 0; g_iAdapter < d3d.AdapterCount; g_iAdapter++)
{
device = new DeviceEx(d3d, d3d.Adapters[g_iAdapter].Adapter, DeviceType.Hardware, hwnd.Handle, CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded, pp);
try
{
cudaDevices = CudaContext.GetDirectXDevices(device.ComPointer, CUd3dXDeviceList.All, CudaContext.DirectXVersion.D3D9);
bDeviceFound = cudaDevices.Length > 0;
infoLog.AppendText("> Display Device #" + d3d.Adapters[g_iAdapter].Adapter
+ ": \"" + d3d.Adapters[g_iAdapter].Details.Description + "\" supports Direct3D9 and CUDA.\n");
break;
}
catch (CudaException)
{
//No Cuda device found for this Direct3D9 device
infoLog.AppendText("> Display Device #" + d3d.Adapters[g_iAdapter].Adapter
+ ": \"" + d3d.Adapters[g_iAdapter].Details.Description + "\" supports Direct3D9 but not CUDA.\n");
}
}
// we check to make sure we have found a cuda-compatible D3D device to work on
if (!bDeviceFound)
{
infoLog.AppendText("No CUDA-compatible Direct3D9 device available");
if (device != null)
device.Dispose();
return false;
}
ctx = new CudaContext(cudaDevices[0], device.ComPointer, CUCtxFlags.BlockingSync, CudaContext.DirectXVersion.D3D9);
deviceName.Text = "Device name: " + ctx.GetDeviceName();
// Set projection matrix
SlimDX.Matrix matProj = SlimDX.Matrix.OrthoOffCenterLH(0, 1, 1, 0, 0, 1);
device.SetTransform(TransformState.Projection, matProj);
// Turn off D3D lighting, since we are providing our own vertex colors
device.SetRenderState(RenderState.Lighting, false);
//Load kernels
CUmodule module = ctx.LoadModulePTX("kernel.ptx");
addForces_k = new CudaKernel("addForces_k", module, ctx);
advectVelocity_k = new CudaKernel("advectVelocity_k", module, ctx);
diffuseProject_k = new CudaKernel("diffuseProject_k", module, ctx);
updateVelocity_k = new CudaKernel("updateVelocity_k", module, ctx);
advectParticles_k = new CudaKernel("advectParticles_k", module, ctx);
d3dimage.Lock();
Surface surf = device.GetBackBuffer(0, 0);
d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, surf.ComPointer);
d3dimage.Unlock();
surf.Dispose();
//Setup the "real" frame rate counter.
//The cuda counter only measures cuda runtime, not the overhead to actually
//show the result via DirectX and WPF.
realLastTick = Environment.TickCount;
return true;
}
private void ReleaseDirect3D()
{
if (direct3D != null)
{
if (!direct3D.Disposed)
{
direct3D.Dispose();
direct3D = null;
}
}
if (direct3DEx != null)
{
if (!direct3DEx.Disposed)
{
direct3DEx.Dispose();
direct3DEx = null;
}
}
}
private void ReleaseDirect3D()
{
if(_direct3D != null && !_direct3D.Disposed)
{
_direct3D.Dispose();
_direct3D = null;
}
if(_direct3DEx != null && !_direct3DEx.Disposed)
{
_direct3DEx.Dispose();
_direct3DEx = null;
}
}
void Initialise()
{
if (this.FHandle == (IntPtr) 0)
throw (new Exception("No shared texture handle set"));
this.FContext = new Direct3DEx();
this.FHiddenControl = new Control();
this.FHiddenControl.Visible = false;
this.FHiddenControl.Width = this.FWidth;
this.FHiddenControl.Height = this.FHeight;
var flags = CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.PureDevice | CreateFlags.FpuPreserve;
this.FDevice = new DeviceEx(FContext, 0, DeviceType.Hardware, this.FHiddenControl.Handle, flags, new PresentParameters()
{
BackBufferWidth = this.FWidth,
BackBufferHeight = this.FHeight
});
this.FTextureShared = new Texture(this.FDevice, this.FWidth, this.FHeight, 1, FUsage, FFormat, Pool.Default, ref this.FHandle);
this.FTextureCopied = new Texture(this.FDevice, this.FWidth, this.FHeight, 1, Usage.RenderTarget, FFormat, Pool.Default);
var description = FTextureCopied.GetLevelDescription(0);
this.FSurfaceOffscreen = Surface.CreateOffscreenPlainEx(FDevice, FWidth, FHeight, description.Format, Pool.SystemMemory, Usage.None);
this.FInitialised = true;
}
