public void TryRender()
{
try
{
if (resized)
{
reset();
}
device.Clear(ClearFlags.Target, Color.Transparent, 0, 0);
device.SetRenderState(RenderState.AlphaBlendEnable, true);
device.SetRenderState(RenderState.CullMode, Cull.Clockwise);
device.BeginScene();
fontRenderer.Begin();
textureRenderer.Begin();
try
{
imguiRenderer.GetNewFrame();
Render.SafeInvoke();
imguiRenderer.Draw();
}
finally
{
textureRenderer.End();
fontRenderer.End();
device.EndScene();
device.Present();
}
renderLocker.Set();
}
catch (SharpDXException)
{
}
}
public void RenderLoop()
{
while (running)
{
try
{
if (resized)
{
reset();
}
device.Clear(ClearFlags.Target, Color.Transparent, 0, 0);
device.SetRenderState(RenderState.AlphaBlendEnable, true);
device.SetRenderState(RenderState.CullMode, Cull.Clockwise);
device.BeginScene();
fontRenderer.Begin();
textureRenderer.Begin();
try
{
Render.SafeInvoke();
}
finally
{
textureRenderer.End();
fontRenderer.End();
device.EndScene();
device.Present();
}
}
catch (SharpDXException) { }
}
renderLocker.Set();
}
public void SetTemporaryRenderState(RenderState renderState, int value)
{
int oldState = _device.GetRenderState(renderState);
if (oldState.Equals(value))
{
return;
}
_changedStates[renderState] = oldState;
_device.SetRenderState(renderState, value);
}
private void display()
{
stopwatch.Start();
advectVelocity(g_dvfield, g_vxfield, g_vyfield, DIM, RPADW, DIM, DT, g_tPitch);
{
g_planr2c.Exec(g_vxfield.DevicePointer);
g_planr2c.Exec(g_vyfield.DevicePointer);
diffuseProject(g_vxfield, g_vyfield, CPADW, DIM, DT, VIS, g_tPitch);
g_planc2r.Exec(g_vxfield.DevicePointer);
g_planc2r.Exec(g_vyfield.DevicePointer);
}
updateVelocity(g_dvfield, g_vxfield, g_vyfield, DIM, RPADW, DIM, g_tPitch);
// Map D3D9 vertex buffer to CUDA
{
graphicsres.MapAllResources();
g_mparticles = graphicsres[0].GetMappedPointer <vertex>();
advectParticles(g_mparticles, g_dvfield, DIM, DIM, DT, g_tPitch);
graphicsres.UnmapAllResources();
}
device.Clear(ClearFlags.Target, new Color4(0.0f, 0, 0), 0.0f, 0);
device.SetRenderState(RenderState.ZWriteEnable, false);
device.SetRenderState(RenderState.AlphaBlendEnable, true);
device.SetRenderState(RenderState.SourceBlend, Blend.One);
device.SetRenderState(RenderState.DestinationBlend, Blend.One);
device.SetRenderState(RenderState.PointSpriteEnable, true);
float size = 16.0f;
device.SetRenderState(RenderState.PointSize, size);
device.SetTexture(0, g_pTexture);
if (device.BeginScene().IsSuccess)
{
Result res;
//Draw particles
res = device.SetStreamSource(0, g_pVB, 0, Marshal.SizeOf(typeof(vertex)));
device.VertexFormat = VertexFormat.Position | VertexFormat.Diffuse;
res = device.DrawPrimitives(PrimitiveType.PointList, 0, DS);
device.EndScene();
}
stopwatch.Stop();
device.Present();
fpsCount++;
if (fpsCount == fpsLimit)
{
float ifps = 1.0f / (stopwatch.GetElapsedTime() / 1000.0f);
string fps = string.Format(System.Globalization.CultureInfo.InvariantCulture, "CUDA/D3D9 Stable Fluids ({0} x {1}): {2} fps", DIM, DIM, ifps);
this.Text = fps;
fpsCount = 0;
fpsLimit = (int)Math.Max(ifps, 1.0f);
}
}
/// <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);
}
}
/// <summary>
/// Sets the directx render states and project matrices.
/// </summary>
public static void SetRenderState()
{
_device.SetRenderState(RenderState.CullMode, Cull.None);
_device.SetRenderState(RenderState.Lighting, false);
_device.SetRenderState(RenderState.ZEnable, false);
_device.SetRenderState(RenderState.ZWriteEnable, false);
_device.SetRenderState(RenderState.FillMode, FillMode.Solid);
EnableDefaultAlphaBlending();
if (_dxCapabilities.SupportsAlphaBlend)
{
EnableAlphaTest();
}
for (int sampler = 0; sampler < 3; sampler++)
{
_device.SetSamplerState(sampler, SamplerState.MinFilter, TextureFilter.Linear);
_device.SetSamplerState(sampler, SamplerState.MagFilter, TextureFilter.Linear);
_device.SetSamplerState(sampler, SamplerState.MipFilter, TextureFilter.None);
}
// Projection onto screen space
SetCameraProjection(Width, Height);
}
/// <summary>
/// Sets the directx render states and project matrices.
/// </summary>
public static void SetRenderState()
{
_device.SetRenderState(RenderState.CullMode, Cull.None);
_device.SetRenderState(RenderState.Lighting, false);
_device.SetRenderState(RenderState.ZEnable, false);
_device.SetRenderState(RenderState.ZWriteEnable, false);
_device.SetRenderState(RenderState.FillMode, FillMode.Solid);
_device.SetRenderState(RenderState.AlphaBlendEnable, true);
_device.SetRenderState(RenderState.SourceBlend, Blend.One);
_device.SetRenderState(RenderState.DestinationBlend, Blend.InverseSourceAlpha);
if (_dxCapabilities.SupportsAlphaBlend)
{
_device.SetRenderState(RenderState.AlphaTestEnable, true);
_device.SetRenderState(RenderState.AlphaRef, 0x05);
_device.SetRenderState(RenderState.AlphaFunc, Compare.GreaterEqual);
}
for (int sampler = 0; sampler < 3; sampler++)
{
_device.SetSamplerState(sampler, SamplerState.MinFilter, TextureFilter.Linear);
_device.SetSamplerState(sampler, SamplerState.MagFilter, TextureFilter.Linear);
_device.SetSamplerState(sampler, SamplerState.MipFilter, TextureFilter.None);
}
// Projection onto screen space
SetCameraProjection(Width, Height);
}
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);
}
private void CompositionTarget_Rendering(object sender, EventArgs e)
{
if (counter++ % 2 == 0)
{
return;
}
//Debug.WriteLine(watch.ElapsedMilliseconds);
if (sizeChanged)
{
pp.BackBufferWidth = (int)ActualWidth;
pp.BackBufferHeight = (int)ActualHeight;
//Device.Reset(pp);
sizeChanged = false;
}
Result result;
if (d3dimage.IsFrontBufferAvailable)
{
result = Device.TestCooperativeLevel();
if (result.IsFailure)
{
throw new Direct3D9Exception();
}
d3dimage.Lock();
Device.SetRenderState(RenderState.CullMode, Cull.None);
Device.SetRenderState(RenderState.ZEnable, true);
Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, new Color4(1, 1, 1, 1), 1.0f, 0);
Device.BeginScene();
var points = animatedDataSource.GetPoints().ToArray();
var pointList = new VertexPositionColor[points.Length];
//phase += 0.01;
//if (phase > 2 * Math.PI)
// phase -= 2 * Math.PI;
//for (int i = 0; i < animatedX.Length; i++)
//{
// animatedX[i] = 2 * Math.PI * i / animatedX.Length;
// if (i % 2 == 0)
// animatedY[i] = Math.Sin(animatedX[i] + phase);
// else
// animatedY[i] = -Math.Sin(animatedX[i] + phase);
//}
for (int i = 0; i < points.Length; i++)
{
pointList[i] = new VertexPositionColor
{
Position = new Vector4(100 + 500 * (float)points[i].X, 500 + 500 * (float)points[i].Y, 0.5f, 1),
Color = Color.Orange.ToArgb()
};
}
var lineListIndices = new short[(points.Length * 2) - 2];
// Populate the array with references to indices in the vertex buffer
for (int i = 0; i < points.Length - 1; i++)
{
lineListIndices[i * 2] = (short)(i);
lineListIndices[(i * 2) + 1] = (short)(i + 1);
}
device.SetRenderState(RenderState.AntialiasedLineEnable, true);
device.VertexFormat = VertexFormat.Diffuse | VertexFormat.PositionRhw;
device.DrawIndexedUserPrimitives <short, VertexPositionColor>(PrimitiveType.LineList, 0, points.Length, points.Length - 1, lineListIndices, Format.Index16, pointList, 20);
//pointList,
//0, // vertex buffer offset to add to each element of the index buffer
//8, // number of vertices in pointList
//lineListIndices, // the index buffer
//0, // first index element to read
//7 // number of primitives to draw
//);
Device.EndScene();
Device.Present();
d3dimage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, Device.GetBackBuffer(0, 0).ComPointer);
d3dimage.AddDirtyRect(new Int32Rect(0, 0, d3dimage.PixelWidth, d3dimage.PixelHeight));
d3dimage.Unlock();
}
}
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);
}
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 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;
}
