public static void CreateDeviceSwapChainAndRenderTarget(Form form,
out Device device, out SwapChain swapChain, out RenderTargetView renderTarget)
{
try
{
// the debug mode requires the sdk to be installed otherwise an exception is thrown
device = new Device(DeviceCreationFlags.Debug);
}
catch (Direct3D10Exception)
{
device = new Device(DeviceCreationFlags.None);
}
var swapChainDescription = new SwapChainDescription();
var modeDescription = new ModeDescription();
var sampleDescription = new SampleDescription();
modeDescription.Format = Format.R8G8B8A8_UNorm;
modeDescription.RefreshRate = new Rational(60, 1);
modeDescription.Scaling = DisplayModeScaling.Unspecified;
modeDescription.ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified;
modeDescription.Width = WIDTH;
modeDescription.Height = HEIGHT;
sampleDescription.Count = 1;
sampleDescription.Quality = 0;
swapChainDescription.ModeDescription = modeDescription;
swapChainDescription.SampleDescription = sampleDescription;
swapChainDescription.BufferCount = 1;
swapChainDescription.Flags = SwapChainFlags.None;
swapChainDescription.IsWindowed = true;
swapChainDescription.OutputHandle = form.Handle;
swapChainDescription.SwapEffect = SwapEffect.Discard;
swapChainDescription.Usage = Usage.RenderTargetOutput;
using (var factory = new Factory())
{
swapChain = new SwapChain(factory, device, swapChainDescription);
}
using (var resource = swapChain.GetBuffer<Texture2D>(0))
{
renderTarget = new RenderTargetView(device, resource);
}
var viewport = new Viewport
{
X = 0,
Y = 0,
Width = WIDTH,
Height = HEIGHT,
MinZ = 0.0f,
MaxZ = 1.0f
};
device.Rasterizer.SetViewports(viewport);
device.OutputMerger.SetTargets(renderTarget);
}
/// <summary>
/// Initializes a new instance of the <see cref="SlimDXRenderWindow"/> class.
/// </summary>
/// <param name="windowHandle">The window handle.</param>
public SlimDXRenderWindow(IntPtr windowHandle)
{
mWindowHandle = windowHandle;
try
{
// the debug mode requires the sdk to be installed otherwise an exception is thrown
mDevice = new Device(DeviceCreationFlags.Debug);
}
catch (Direct3D10Exception)
{
mDevice = new Device(DeviceCreationFlags.None);
}
if (mIsWindowed)
{
mHeight = HEIGHT;
mWidth = WIDTH;
}
else
{
mWidth = 1280;
mHeight = 1024;
}
CreateSwapChainRenderTargetAndViewport();
SetRasterizeStateDescription();
}
public DxEffect(SlimDX.Direct3D10.Device device, string shaderFileName = "scene.fx")
{
// using (var bytecode = ShaderBytecode.CompileFromFile(shaderFileName, "VShader", vs))
_dxDevice = device;
_effect = Effect.FromFile(_dxDevice, shaderFileName, "fx_4_0",
ShaderFlags.None, EffectFlags.None, null, null);
_technique = _effect.GetTechniqueByName("Render"); //C++ Comparaison// technique = effect->GetTechniqueByName( "Render" );
_effectPass = _technique.GetPassByIndex(0);
_worldVariable = _effect.GetVariableByName("World").AsMatrix(); //C++ Comparaison// worldVariable = effect->GetVariableByName( "World" )->AsMatrix();
_viewVariable = _effect.GetVariableByName("View").AsMatrix();
_projectionVariable = _effect.GetVariableByName("Projection").AsMatrix();
ShaderSignature signature = _effectPass.Description.Signature;
_inputLayout = new InputLayout(_dxDevice, signature, new[]
{
//C++...// { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
new InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 0, 0), // 8bits = 1 bytes, so 32bits = 4 bytes, then R32+G32+B32+A32 = 4+4+4+4 = 16 bytes
new InputElement("COLOR", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 16, 0) // 16 = total bytes from the element before, here it's "POSITION"
});
_effect.Optimize();
}
/// <summary>
/// Creates a new instance of <see cref="D3D10RenderSystemProvider"/> using the adapter index.
/// </summary>
/// <param name="adapterIndex">Index of the adapter to use when creating the underlying device</param>
public D3D10RenderSystemProvider(int adapterIndex)
{
//Create the DXGI Factory
DXGI.Factory factory = new DXGI.Factory();
//Create the device
DXGI.Adapter adapter = factory.GetAdapter(adapterIndex);
D3D.Device device = new D3D.Device(adapter, D3D.DriverType.Hardware, D3D.DeviceCreationFlags.None);
//Enumerate adapters
List <IGraphicsAdapter> adapterList = new List <IGraphicsAdapter>();
int adapterCount = factory.GetAdapterCount();
for (int i = 0; i < adapterCount; i++)
{
adapterList.Add(new D3D10GraphicsAdapter(device, factory, i));
}
_adapters = new ReadOnlyList <IGraphicsAdapter>(adapterList);
//Create the renderer
_renderer = new D3D10Renderer(factory, device, (D3D10GraphicsAdapter)adapterList[adapterIndex]);
//Create default content manager
_content = new ContentManager(new EmbeddedResourceLocator(Tesla.Direct3D10.DefaultContent.ResourceManager));
_content.UseDefaultContent = false;
}
/// <summary>
/// Creates a new instance of <see cref="D3D10IndexBufferImplementation"/>.
/// </summary>
/// <param name="renderer">The D3D renderer.</param>
/// <param name="format">The index format.</param>
/// <param name="indexCount">The number of indices.</param>
/// <param name="usage">The buffer usage specifying what type of memory the buffer should be created in.</param>
internal D3D10IndexBufferImplementation(D3D10Renderer renderer, IndexFormat format, int indexCount, ResourceUsage usage)
: base(format, indexCount, usage)
{
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
int formatBytes = (format == IndexFormat.ThirtyTwoBits) ? 4 : 2;
try {
//Determine appropiate vertex buffer to create
if (usage == ResourceUsage.Static)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Default;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.None;
_buffer = new D3D.Buffer(_graphicsDevice, new D3D.BufferDescription(indexCount * formatBytes, rUsage, D3D.BindFlags.IndexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
else if (usage == ResourceUsage.Dynamic)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Dynamic;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.Write;
_buffer = new D3D.Buffer(_graphicsDevice, new D3D.BufferDescription(indexCount * formatBytes, rUsage, D3D.BindFlags.IndexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
//Add to tracker
_renderer.Resources.AddTrackedObject(_buffer.ComPointer, this);
} catch (Exception e) {
Dispose();
throw new TeslaException("Error creating DX10 buffer:\n" + e.Message);
}
}
/// <summary>
/// Creates a new instance of <see cref="D3D10EffectImplementation"/>.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="shaderByteCode">The compiled shader byte code.</param>
/// <param name="profileName">Name of the shader profile.</param>
/// <param name="sFlags">The shader flags.</param>
/// <param name="eFlags">The effect flags.</param>
internal D3D10EffectImplementation(D3D10Renderer renderer, byte[] shaderByteCode, String profileName, D3DC.ShaderFlags sFlags, D3DC.EffectFlags eFlags)
{
_cachedByteCode = shaderByteCode;
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
_profileName = profileName;
_sFlags = sFlags;
_eFlags = eFlags;
_effect = D3D.Effect.FromMemory(_graphicsDevice, _cachedByteCode, _profileName, _sFlags, _eFlags, null, null, null);
//Add to resource tracker
_renderer.Resources.AddTrackedObject(_effect.ComPointer, this);
int techCount = _effect.Description.TechniqueCount;
D3D10EffectTechniqueCollection techniques = new D3D10EffectTechniqueCollection();
D3D10EffectParameterCollection parameters = new D3D10EffectParameterCollection();
base.SetTechniques(techniques);
base.SetParameters(parameters);
for (int i = 0; i < techCount; i++)
{
D3D10EffectTechnique tech = new D3D10EffectTechnique(this, _effect, _effect.GetTechniqueByIndex(i));
((D3D10EffectTechniqueCollection)techniques).Add(tech);
}
//Set the current technique, the first one by default
_currentTechnique = (D3D10EffectTechnique)techniques[0];
}
//String shader2 = "sampler2D g_samSrcColor;float4 MyShader( float4 Tex : TEXCOORD0 ) : COLOR0{float4 Color;Color = tex2D( g_samSrcColor, Tex.xy);return Color;}";
private void DrawSprite(SlimDX.Direct3D10.Device device)
{
if (_sprite == null)
{
_sprite = new Sprite(device, 1);
_sTexture = Texture2D.FromFile(
device,
@"C:\temp\privet.png");
_srv = new ShaderResourceView(device, _sTexture);
_si[0] = new SpriteInstance(_srv, new Vector2(0, 0), new Vector2(1, 1));
//_sprite.ProjectionTransform = Matrix.OrthoOffCenterLH(0, 800, -600, 0, -10, 10);
_sprite.ViewTransform = Matrix.Transformation2D(Vector2.Zero, 0.0f, new Vector2(2.0f, 2.0f), Vector2.Zero, 0.0f, Vector2.Zero);
using (var bytecode = ShaderBytecode.Compile(shader, "PShader", "ps_4_0", ShaderFlags.EnableBackwardsCompatibility, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
}
device.PixelShader.Set(pixelShader);
//if ((DateTime.Now - _lastSprite).TotalMilliseconds > 0)
//{
_sprite.Begin(SpriteFlags.None);
_sprite.DrawImmediate(_si);
_sprite.End();
_lastSprite = DateTime.Now;
//}
}
public SpriteQuad(Device device, int maxInstances) : base(device)
{
int slot = 0;
AddVetexStreamBuffer(new VertexStreamBuffer<SpriteVertex>(InternalDevice,
CreateQuadVertices(),
slot,
ResourceUsage.Default),
CreateInputElements());
AddIndexStreamBuffer(CreateIndices());
int totalBufferSize = 16;/* FIX ME: Size needs to be multiples of 16... or is it 8? */
m_vertexBatchConstantBuffer = new ConstantStreamBuffer<VertexConstantData>(InternalDevice,
totalBufferSize,
0,
ConstantStreamBufferType.VertexShader,
ResourceUsage.Dynamic,
CpuAccessFlags.Write);
m_streamBuffers.Add(m_vertexBatchConstantBuffer);
totalBufferSize = Marshal.SizeOf(typeof(SpriteDrawData)) * maxInstances;
slot = 1;
m_instanceDataStream = new VertexStreamBuffer<SpriteDrawData>(device,
totalBufferSize,
slot,
ResourceUsage.Dynamic,
CpuAccessFlags.Write);
m_streamBuffers.Add(m_instanceDataStream);
}
public override void Initialize()
{
using (var fac = new Factory())
{
using (var tmpDevice = new Device(fac.GetAdapter(0), DriverType.Hardware, DeviceCreationFlags.None))
{
using (var rf = new RenderForm())
{
var desc = new SwapChainDescription
{
BufferCount = 1,
Flags = SwapChainFlags.None,
IsWindowed = true,
ModeDescription = new ModeDescription(100, 100, new Rational(60, 1), Format.R8G8B8A8_UNorm),
OutputHandle = rf.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
using (var sc = new SwapChain(fac, tmpDevice, desc))
{
PresentPointer = Pulse.Magic.GetObjectVtableFunction(sc.ComPointer, VMT_PRESENT);
ResetTargetPointer = Pulse.Magic.GetObjectVtableFunction(sc.ComPointer, VMT_RESIZETARGET);
}
}
}
}
_presentDelegate = Pulse.Magic.RegisterDelegate<Direct3D10Present>(PresentPointer);
_presentHook = Pulse.Magic.Detours.CreateAndApply(_presentDelegate, new Direct3D10Present(Callback), "D10Present");
}
/// <summary>
/// Creates a new instance of <see cref="D3D10VertexBufferImplementation"/>.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="decl">The vertex declaration.</param>
/// <param name="vertexCount">The vertex count.</param>
/// <param name="usage">The resource usage.</param>
/// <exception cref="Tesla.Core.TeslaException">Thrown if creating the underlying D3D10 buffer failed.</exception>
internal D3D10VertexBufferImplementation(D3D10Renderer renderer, VertexDeclaration decl, int vertexCount, ResourceUsage usage)
: base(decl, vertexCount, usage)
{
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
try {
//Determine appropiate vertex buffer to create, let any exceptions bubble up.
if (base.BufferUsage == ResourceUsage.Static)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Default;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.None;
_buffer = new D3D.Buffer(_graphicsDevice, new D3D.BufferDescription(vertexCount * decl.VertexStride, rUsage, D3D.BindFlags.VertexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
else if (base.BufferUsage == ResourceUsage.Dynamic)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Dynamic;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.Write;
_buffer = new D3D.Buffer(_graphicsDevice, new D3D.BufferDescription(vertexCount * decl.VertexStride, rUsage, D3D.BindFlags.VertexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
//Add to tracker
_renderer.Resources.AddTrackedObject(_buffer.ComPointer, this);
} catch (Exception e) {
Dispose();
throw new TeslaException("Error creating D3D10 buffer: \n" + e.Message, e);
}
}
/// <summary>
/// Creates a new instance of <see cref="D3D10VertexBufferImplementation"/> initialized with the interleaved data.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="decl">The vertex declaration.</param>
/// <param name="usage">The resource usage.</param>
/// <param name="data">The interleaved data.</param>
/// <exception cref="Tesla.Core.TeslaException">Thrown if creating the underlying D3D10 buffer or writing to it failed.</exception>
internal D3D10VertexBufferImplementation(D3D10Renderer renderer, VertexDeclaration decl, ResourceUsage usage, DataBuffer data)
: base(decl, usage, data)
{
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
//Determine appropiate buffer, let any exceptions bubble up.
try {
using (SDX.DataStream ds = new SDX.DataStream(data.ByteDataCopy, true, false)) {
//Now create and populate appropiate D3D10 buffer
if (base.BufferUsage == ResourceUsage.Static)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Default;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.None;
_buffer = new D3D.Buffer(_graphicsDevice, ds, new D3D.BufferDescription(data.SizeInBytes, rUsage, D3D.BindFlags.VertexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
else if (base.BufferUsage == ResourceUsage.Dynamic)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Dynamic;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.Write;
_buffer = new D3D.Buffer(_graphicsDevice, ds, new D3D.BufferDescription(data.SizeInBytes, rUsage, D3D.BindFlags.VertexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
}
//Add to tracker
_renderer.Resources.AddTrackedObject(_buffer.ComPointer, this);
} catch (Exception e) {
Dispose();
throw new TeslaException("Error creating D3D10 buffer: \n" + e.Message, e);
}
}
private void InitDeviceAndSwapChain(SwapChainDescription currentDescription)
{
DeviceCreationFlags flags = DeviceCreationFlags.None;
#if DEBUG
// flags |= DeviceCreationFlags.Debug;
#endif
flags |= DeviceCreationFlags.SingleThreaded;
DriverType type;
#if SOFTWARE
type = DriverType.Warp;
#else
type = DriverType.Hardware;
#endif
Device.CreateWithSwapChain(null, type, flags, currentDescription, out device, out swapChain);
// Stops Alt + Enter from causing fullscreen skrewiness.
using (Factory factory = swapChain.GetParent <Factory>())
{
factory.SetWindowAssociation(renderFrame.Handle, WindowAssociationFlags.IgnoreAltEnter);
}
}
/// <summary>
/// Creates a new instance of <see cref="D3D10Renderer"/>.
/// </summary>
/// <param name="factory">The DXGI factory used to create the adapter for the device.</param>
/// <param name="graphicsDevice">The graphics device created by the render system.</param>
/// <param name="adapter">The graphics adapter used to create the device.</param>
internal D3D10Renderer(DXGI.Factory factory, D3D.Device graphicsDevice, D3D10GraphicsAdapter adapter)
{
_factory = factory;
_graphicsDevice = graphicsDevice;
_adapter = adapter;
CreateHelpers();
}
int mipbias = 4; // 3 is sufficient, but at 4 it loads
#endregion Fields
#region Constructors
public VirtualTexture( D3D10.Device device, VirtualTextureInfo info, int atlassize, int uploadsperframe, string filename )
{
this.device = device;
this.info = info;
this.atlascount = atlassize / info.PageSize;
this.uploadsperframe = uploadsperframe;
indexer = new PageIndexer( info );
toload = new List<PageCount>( indexer.Count );
Console.Write( "Creating PageAtlas...");
atlas = new TextureAtlas( device, info, atlascount, uploadsperframe );
Console.WriteLine("done.");
Console.Write( "Creating PageLoader..." );
loader = new PageLoader( filename + ".cache", indexer, info );
Console.WriteLine("done.");
cache = new PageCache( info, atlas, loader, indexer, atlascount );
Console.Write( "Creating PageTable...");
pagetable = new PageTable( device, cache, info, indexer );
Console.WriteLine("done.");
}
private void InitD3D()
{
{
SwapChainDescription swap_chain_desc = new SwapChainDescription();
swap_chain_desc.BufferCount = 2;
swap_chain_desc.OutputHandle = m_Window.Handle;
swap_chain_desc.IsWindowed = true;
swap_chain_desc.ModeDescription = new ModeDescription(m_Window.Width, m_Window.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm);
swap_chain_desc.SampleDescription = new SampleDescription(1, 0);
swap_chain_desc.SwapEffect = SwapEffect.Discard;
swap_chain_desc.Usage = Usage.RenderTargetOutput;
if (D3DDevice.CreateWithSwapChain(null, DriverType.Hardware, 0, swap_chain_desc, out m_D3DDevice, out m_SwapChain).IsFailure)
{
throw new Exception("Bad stuff happened");
}
m_D3DDevice.Factory.SetWindowAssociation(m_Window.Handle, WindowAssociationFlags.IgnoreAll);
}
using (Texture2D back_buffer = Texture2D.FromSwapChain <Texture2D>(m_SwapChain, 0)) {
m_RenderTargetView = new RenderTargetView(m_D3DDevice, back_buffer);
}
{
var tex_desc = new Texture2DDescription();
tex_desc.Width = m_Window.Width;
tex_desc.Height = m_Window.Height;
tex_desc.SampleDescription = new SampleDescription(1, 0);
tex_desc.Format = Format.D32_Float;
tex_desc.MipLevels = 1;
tex_desc.ArraySize = 1;
tex_desc.BindFlags = BindFlags.DepthStencil;
tex_desc.CpuAccessFlags = CpuAccessFlags.None;
tex_desc.Usage = ResourceUsage.Default;
tex_desc.OptionFlags = ResourceOptionFlags.None;
var depth_buffer = new Texture2D(m_D3DDevice, tex_desc);
m_DepthStencilView = new DepthStencilView(m_D3DDevice, depth_buffer);
}
m_D3DDevice.OutputMerger.SetTargets(m_DepthStencilView, m_RenderTargetView);
//m_D3DDevice.OutputMerger.SetTargets(m_RenderTargetView);
{
Viewport viewport = new Viewport(0, 0, m_Window.Width, m_Window.Height, 0, 1);
m_D3DDevice.Rasterizer.SetViewports(viewport);
}
m_Effect = Effect.FromFile(m_D3DDevice, "effect.fx", "fx_4_0");
m_Tex = Texture2D.FromFile(m_D3DDevice, "IMG_4788.jpg");
GenerateGeometry();
m_Start = DateTime.Now;
}
public DxCube(Device device)
{
_dxDevice = device;
// LoadEffect();
CreateVertexBuffer();
CreateIndexBuffer();
}
public StagingTexture(Device device,
int width,
int height,
Format format = Format.B8G8R8A8_UNorm,
ResourceOptionFlags optionFlags = ResourceOptionFlags.None)
: base(new Texture2D(device, CreateTextureDescription(width, height, format, optionFlags)))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicPrimitiveBuffer10"/> class.
/// </summary>
/// <param name="device">The device.</param>
public DynamicPrimitiveBuffer10(D3D.Device device)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
this.device = device;
}
public DxCube(Device device)
{
_dxDevice = device;
// LoadEffect();
CreateVertexBuffer();
CreateIndexBuffer();
}
public RenderTargetTexture(Device device,
int width,
int height,
Format format = Format.B8G8R8A8_UNorm,
ResourceOptionFlags optionFlags = ResourceOptionFlags.None)
: base(new Texture2D(device, CreateTextureDescription(width, height, format, optionFlags)))
{
InternalRenderTargetView = new RenderTargetView(device, InternalTexture2D);
}
public TextureAtlas( D3D10.Device device, VirtualTextureInfo info, int count, int uploadsperframe )
{
this.device = device;
this.info = info;
int pagesize = info.PageSize;
resource = new Direct3D.Texture( device, count * pagesize, count * pagesize, DXGI.Format.R8G8B8A8_UNorm, D3D10.ResourceUsage.Default, 1 );
staging = new Direct3D.StagingTexturePool( device, pagesize, pagesize, DXGI.Format.R8G8B8A8_UNorm, uploadsperframe, D3D10.CpuAccessFlags.Write );
}
private static void PrintSupportedFormats(Device device) {
Console.WriteLine(" Format Support:");
foreach (var format in Enum.GetValues(typeof(Format))) {
Console.WriteLine(" Format: {0}", format);
var formatSupport = device.CheckFormatSupport((Format)format);
Console.WriteLine(" Format support: {0}", formatSupport);
PrintSupportedQualityLevels(device, (Format) format);
}
}
protected override void OnExit(ExitEventArgs e)
{
if (D3DDevice != null)
{
D3DDevice.Dispose();
D3DDevice = null;
}
base.OnExit(e);
}
/// <summary>
/// Creates a new instance of <see cref="D3D10TextureCollection"/>.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="maxTextures">The max textures count.</param>
/// <param name="vertexTextures">True if this is meant for vertex shader textures, false for pixel shader textures.</param>
internal D3D10TextureCollection(D3D10Renderer renderer, int maxTextures, bool vertexTextures)
{
_renderer = renderer;
_graphicsDevice = renderer.GraphicsDevice;
_vertexTex = vertexTextures;
_maxTextures = maxTextures;
_textures = new Texture[_maxTextures];
_dirtyMark = new bool[_maxTextures];
_shortCircuitUpdate = false;
}
internal static void EnsureD3D10()
{
if (Factory == null)
{
SlimDX.Direct3D10.Device device = new SlimDX.Direct3D10.Device(DeviceCreationFlags.None);
device.Dispose();
Factory = new Factory();
}
}
/// <summary>
/// Creates a new instance of <see cref="D3D10SamplerStateCollection"/>.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="maxSamplers">The max sampler count.</param>
/// <param name="vertexSamplers">True if this is meant for vertex shader samplers, false for pixel shader samplers.</param>
internal D3D10SamplerStateCollection(D3D10Renderer renderer, int maxSamplers, bool vertexSamplers)
{
_renderer = renderer;
_graphicsDevice = renderer.GraphicsDevice;
_maxSamplers = maxSamplers;
_vertexSamplers = vertexSamplers;
_samplers = new SamplerState[maxSamplers];
_dirtyMark = new bool[maxSamplers];
_shortCircuitUpdate = false;
}
static void Main(string[] args)
{
using (D3D10.Device device = new D3D10.Device(D3D10.DeviceCreationFlags.None))
{
//build single mesh from world editor
string meshArgs = args != null && args.Length > 0 ? args[0] : "skull.X,NormalMesh";//"block1.X,NormalMesh";
BuildMesh(device, meshArgs);
}
return;
}
public DrawIndexedBatch(Device device, Effect effect, IEnumerable<VertexBufferBinding> vertexBuffers, InputLayout inputLayout,
Buffer indexBuffer, Format indexBufferFormat,
int indexCount, int startIndex, int baseVertex)
: base(device, effect, vertexBuffers, inputLayout)
{
IndexBuffer = indexBuffer;
IndexBufferFormat = indexBufferFormat;
IndexCount = indexCount;
StartIndex = startIndex;
BaseVertex = baseVertex;
}
public InputLayoutMap(D3D10Renderer renderer, D3DC.ShaderSignature shaderSignature)
{
_device = renderer.GraphicsDevice;
_sig = shaderSignature;
_layoutMap = new Dictionary <int, D3D.InputLayout>();
_semanticIndexCount = new int[Enum.GetValues(typeof(VertexSemantic)).Length];
_isDisposed = false;
renderer.Disposing += new EventHandler(delegate(object o, EventArgs args) {
Dispose();
});
}
public DrawIndexedBatch(Device device, Effect effect, IEnumerable <VertexBufferBinding> vertexBuffers, InputLayout inputLayout,
Buffer indexBuffer, Format indexBufferFormat,
int indexCount, int startIndex, int baseVertex)
: base(device, effect, vertexBuffers, inputLayout)
{
IndexBuffer = indexBuffer;
IndexBufferFormat = indexBufferFormat;
IndexCount = indexCount;
StartIndex = startIndex;
BaseVertex = baseVertex;
}
/// <summary>
/// Creates a new render target manager.
/// </summary>
/// <param name="renderer">D3D10 renderer</param>
/// <param name="maxTargets">Max targets</param>
public RenderTargetManager(D3D10Renderer renderer, int maxTargets)
{
_renderer = renderer;
_graphicsDevice = renderer.GraphicsDevice;
_views = new D3D.RenderTargetView[maxTargets];
_currentRenderTargets = new RenderTargetBinding[maxTargets];
_targetsToMipMap = new RenderTargetBinding[maxTargets];
_activeBackBuffer = null;
_currentRenderTargetCount = 0;
_targetsToMipMapCount = 0;
}
private static void PrintSupportedFormats(Device device)
{
Console.WriteLine(" Format Support:");
foreach (var format in Enum.GetValues(typeof(Format)))
{
Console.WriteLine(" Format: {0}", format);
var formatSupport = device.CheckFormatSupport((Format)format);
Console.WriteLine(" Format support: {0}", formatSupport);
PrintSupportedQualityLevels(device, (Format)format);
}
}
internal static void CheckDisposed(D3D.Device device)
{
if (device == null)
{
throw new ArgumentNullException("Graphics device is null.");
}
if (device.Disposed)
{
throw new ObjectDisposedException("Underlying device has been disposed.");
}
}
/// <summary>
/// Creates a new instance of <see cref="D3D10SwapChainImplementation"/>.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="factory">The DXGI factory.</param>
/// <param name="windowHandle">The window handle.</param>
/// <param name="presentParams">The presentation parameters to initialize to.</param>
internal D3D10SwapChainImplementation(D3D10Renderer renderer, DXGI.Factory factory, IntPtr windowHandle, PresentationParameters presentParams)
{
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
_factory = factory;
_resetting = false;
_isFullScreen = false;
_presentParams = presentParams;
_windowHandle = windowHandle;
CreateSwapChain(_windowHandle, _presentParams);
CreateViews();
}
public DxParticleSystemRenderer(Device device, ShaderResourceView texArrayRV, int maxParticles)
{
_dxDevice = device;
_maxParticles = maxParticles;
_texArrayRV = texArrayRV;
BuildRandomTexture();
LoadEffect(@"Assets\fire.fx");
BuildVertexBuffer();
Reset();
}
public ShaderQuad(Device device) : base(device)
{
int slot = 0;
/* Run our helper method to create a vertex buffer
* using our QuadVertex vertex structure */
AddVetexStreamBuffer(new VertexStreamBuffer<QuadVertex>(InternalDevice,
CreateQuadVertices(),
slot,
ResourceUsage.Default),
CreateInputElements());
AddIndexStreamBuffer(CreateIndices());
}
protected override void DrawText(Object dev, String text, String text2 = null, int alpha = 0)
{
Texture2D texture = (Texture2D)dev;
SlimDX.Direct3D10.Device device = texture.Device;
#region Save BlendState. Maybe can be done with less code?
BlendState bs = device.OutputMerger.BlendState;
Color4 bf = device.OutputMerger.BlendFactor;
int bsm = device.OutputMerger.BlendSampleMask;
int dsr = device.OutputMerger.DepthStencilReference;
DepthStencilState dss = device.OutputMerger.DepthStencilState;
#endregion
if (_font == null)
{
_sprite = new Sprite(device, 256);
_font = new SlimDX.Direct3D10.Font(device, _fd);
}
_sprite.Begin(SpriteFlags.None);
_font.Draw(_sprite,
text,
new System.Drawing.Rectangle(0, 0, texture.Description.Width, texture.Description.Height),
FontDrawFlags.Top | FontDrawFlags.Right | FontDrawFlags.NoClip,
System.Drawing.Color.Red);
if (alpha > 0)
{
Color c = Color.FromArgb(alpha, System.Drawing.Color.Red);
_font.Draw(_sprite,
text2,
new System.Drawing.Rectangle(0, 15, texture.Description.Width, texture.Description.Height - 15),
FontDrawFlags.Top | FontDrawFlags.Right | FontDrawFlags.NoClip,
c);
}
_sprite.End();
#region Restore Blend State
device.OutputMerger.BlendState = bs;
device.OutputMerger.DepthStencilState = dss;
device.OutputMerger.BlendSampleMask = bsm;
device.OutputMerger.BlendFactor = bf;
device.OutputMerger.DepthStencilReference = dsr;
#endregion
}
public RenderTargetArrayHolder(Device device, int width, int height, Format format, int layerCount)
{
Debug.Assert(device != null);
this.device = device;
this.width = width;
this.height = height;
this.format = format;
this.layerCount = layerCount;
CreateTexture();
CreateShaderResourceView();
CreateRenderTargetView();
}
public RenderTargetArrayHolder(Device device, int width, int height, Format format, int layerCount)
{
Debug.Assert(device != null);
this.device = device;
this.width = width;
this.height = height;
this.format = format;
this.layerCount = layerCount;
CreateTexture();
CreateShaderResourceView();
CreateRenderTargetView();
}
private void InitializeD3D10()
{
// Create DXGI factory
factory = new Factory();
Adapter selectedAdapter = null;
DriverType driverType = DriverType.Hardware;
DeviceCreationFlags deviceCreationFlags = DeviceCreationFlags.None;
#if DEBUG
// Try to find the "NVIDIA PerfHUD" adapter
for (int i = 0; i < factory.GetAdapterCount(); ++i)
{
Adapter adapter = factory.GetAdapter(i);
bool isPerfHUD = adapter.Description.Description == "NVIDIA PerfHUD";
if (i == 0 || isPerfHUD)
{
selectedAdapter = adapter;
}
if (isPerfHUD)
{
driverType = DriverType.Reference;
}
}
// Enable debug layer
deviceCreationFlags = DeviceCreationFlags.Debug;
#endif
// Create the device.
device = new Device(selectedAdapter, driverType, deviceCreationFlags);
// Create a swap chain.
var modeDescription = new ModeDescription(rendererConfiguration.BackBufferWidth, rendererConfiguration.BackBufferHeight,
rendererConfiguration.RefreshRate, rendererConfiguration.BackBufferFormat);
var swapChainDescription = new SwapChainDescription
{
BufferCount = 1,
IsWindowed = rendererConfiguration.Windowed,
Flags = SwapChainFlags.AllowModeSwitch,
OutputHandle = control.Handle,
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
ModeDescription = modeDescription,
SampleDescription = new SampleDescription(1, 0),
};
swapChain = new SwapChain(factory, device, swapChainDescription);
}
static void EnumerateDevices(AdapterInfo10 adapterInfo)
{
DriverType[] allowedTypes = { DriverType.Hardware, DriverType.Reference };
foreach (DriverType type in allowedTypes)
{
if (MinimumSettings != null && type != MinimumSettings.DeviceType)
{
continue;
}
DeviceInfo10 deviceInfo = new DeviceInfo10();
deviceInfo.AdapterOrdinal = adapterInfo.AdapterOrdinal;
deviceInfo.DriverType = type;
SlimDX.Direct3D10.Device device;
try
{
Adapter adapter = null;
if (type == DriverType.Hardware)
{
adapter = adapterInfo.Adapter;
}
device = new SlimDX.Direct3D10.Device(adapter, type, DeviceCreationFlags.None);
}
catch (Direct3D10Exception)
{
// swallow the exception
continue;
}
// if the driver type is not hardware, create a DXGI device and GetAdapter
// from it to replace adapterInfo.Adapter
if (type != DriverType.Hardware)
{
SlimDX.DXGI.Device dxgiDevice = new SlimDX.DXGI.Device(device);
if (adapterInfo.Adapter != null)
{
adapterInfo.Adapter.Dispose();
}
adapterInfo.Adapter = dxgiDevice.Adapter;
dxgiDevice.Dispose();
}
device.Dispose();
adapterInfo.Devices.Add(deviceInfo);
}
}
/// <summary>
/// Creates a new instance of <see cref="D3D10VertexBufferImplementation"/> initialized with the vertex data array.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="decl">The vertex declaration.</param>
/// <param name="usage">The resource usage.</param>
/// <param name="data">The array of vertex data.</param>
/// <exception cref="Tesla.Core.TeslaException">Thrown if creating the underlying D3D10 buffer or writing to it failed.</exception>
internal D3D10VertexBufferImplementation(D3D10Renderer renderer, VertexDeclaration decl, ResourceUsage usage, params DataBuffer[] data)
: base(decl, usage, data)
{
_renderer = renderer;
_graphicsDevice = renderer.GraphicsDevice;
int totalSizeInBytes = base.VertexCount * decl.VertexStride;
int vertexStride = decl.VertexStride;
try {
//Now initialize the buffer with the supplied vertex store
using (SDX.DataStream interleaved = new SDX.DataStream(totalSizeInBytes, true, true)) {
//Create the interleaved buffer
byte[] vertex = new byte[vertexStride];
for (int i = 0; i < base.VertexCount; i++)
{
int offset = 0;
for (int j = 0; j < data.Length; j++)
{
DataBuffer db = data[j];
int elementSize = db.ElementSizeInBytes;
db.Get(vertex, offset, elementSize);
offset += elementSize;
}
interleaved.Write(vertex, 0, vertexStride);
}
interleaved.Position = 0;
//Now create and populate appropiate D3D10 buffer
if (base.BufferUsage == ResourceUsage.Static)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Default;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.None;
_buffer = new D3D.Buffer(_graphicsDevice, interleaved, new D3D.BufferDescription(totalSizeInBytes, rUsage, D3D.BindFlags.VertexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
else if (base.BufferUsage == ResourceUsage.Dynamic)
{
D3D.ResourceUsage rUsage = D3D.ResourceUsage.Dynamic;
D3D.CpuAccessFlags cpuAccess = D3D.CpuAccessFlags.Write;
_buffer = new D3D.Buffer(_graphicsDevice, interleaved, new D3D.BufferDescription(totalSizeInBytes, rUsage, D3D.BindFlags.VertexBuffer, cpuAccess, D3D.ResourceOptionFlags.None));
}
}
//Add to tracker
_renderer.Resources.AddTrackedObject(_buffer.ComPointer, this);
} catch (Exception e) {
Dispose();
throw new TeslaException("Error creating D3D10 buffer: \n" + e.Message, e);
}
}
public override void Hook()
{
this.DebugMessage("Hook: Begin");
// Determine method addresses in Direct3D10.Device, and DXGI.SwapChain
if (_d3d10VTblAddresses == null)
{
_d3d10VTblAddresses = new List <IntPtr>();
_dxgiSwapChainVTblAddresses = new List <IntPtr>();
this.DebugMessage("Hook: Before device creation");
using (SlimDX.DXGI.Factory factory = new SlimDX.DXGI.Factory())
{
using (SlimDX.Direct3D10.Device device = new Device(factory.GetAdapter(0), DriverType.Hardware, DeviceCreationFlags.None))
{
this.DebugMessage("Hook: Device created");
_d3d10VTblAddresses.AddRange(GetVTblAddresses(device.ComPointer, D3D10_DEVICE_METHOD_COUNT));
using (SlimDX.Windows.RenderForm renderForm = new SlimDX.Windows.RenderForm())
{
using (SlimDX.DXGI.SwapChain sc = new SlimDX.DXGI.SwapChain(factory, device, DXGI.CreateSwapChainDescription(renderForm.Handle)))
{
_dxgiSwapChainVTblAddresses.AddRange(GetVTblAddresses(sc.ComPointer, DXGI.DXGI_SWAPCHAIN_METHOD_COUNT));
}
}
}
}
}
// We will capture the backbuffer here
DXGISwapChain_PresentHook = LocalHook.Create(
_dxgiSwapChainVTblAddresses[(int)DXGI.DXGISwapChainVTbl.Present],
new DXGISwapChain_PresentDelegate(PresentHook),
this);
// We will capture target/window resizes here
DXGISwapChain_ResizeTargetHook = LocalHook.Create(
_dxgiSwapChainVTblAddresses[(int)DXGI.DXGISwapChainVTbl.ResizeTarget],
new DXGISwapChain_ResizeTargetDelegate(ResizeTargetHook),
this);
/*
* Don't forget that all hooks will start deactivated...
* The following ensures that all threads are intercepted:
* Note: you must do this for each hook.
*/
DXGISwapChain_PresentHook.ThreadACL.SetExclusiveACL(new Int32[1]);
DXGISwapChain_ResizeTargetHook.ThreadACL.SetExclusiveACL(new Int32[1]);
}
private static void PrintSupportedQualityLevels(Device device, Format format) {
for (var sampleCount = 1; sampleCount <= 32; sampleCount *= 2) {
var qualityLevels = device.CheckMultisampleQualityLevels(format, sampleCount);
Console.WriteLine(" Sample Count: {0}", sampleCount);
if (qualityLevels != 0)
Console.WriteLine(" Max Quality Level: {0}", qualityLevels);
else {
Console.WriteLine(" Not supported");
}
if (qualityLevels == 0)
break;
}
}
public DepthStencilBufferArrayHolder(Device device,
RendererConfiguration rendererConfiguration, DeferredShadingConfiguration deferredShadingConfiguration)
{
Debug.Assert(device != null && rendererConfiguration != null && deferredShadingConfiguration != null);
this.device = device;
this.rendererConfiguration = rendererConfiguration;
this.deferredShadingConfiguration = deferredShadingConfiguration;
depthStencilViewsReadOnly = new ReadOnlyCollection<DepthStencilView>(depthStencilViews);
shaderResourceViewsReadOnly = new ReadOnlyCollection<ShaderResourceView>(shaderResourceViews);
CreateTexture();
CreateDepthStencilViews();
CreateShaderResourceViews();
}
public RenderTargetArrayHolder(Device device, RenderTargetDescription description,
RendererConfiguration rendererConfiguration, DeferredShadingConfiguration deferredShadingConfiguration)
{
Debug.Assert(device != null && description != null && rendererConfiguration != null &&
deferredShadingConfiguration != null);
this.device = device;
this.description = description;
this.rendererConfiguration = rendererConfiguration;
this.deferredShadingConfiguration = deferredShadingConfiguration;
renderTargetViewsReadOnly = new ReadOnlyCollection<RenderTargetView>(renderTargetViews);
CreateTexture();
CreateRenderTargetViews();
CreateShaderResourceView();
}
public PageTable( D3D10.Device device, PageCache cache, VirtualTextureInfo info, PageIndexer indexer )
{
this.info = info;
this.device = device;
this.indexer = indexer;
quadtree = new Quadtree(new Rectangle(0, 0, info.PageTableSize, info.PageTableSize), MathExtensions.Log2(info.PageTableSize));
int size = info.PageTableSize;
texture = new Direct3D.Texture( device, size, size, DXGI.Format.R8G8B8A8_UNorm, D3D10.ResourceUsage.Default, 0 );
staging = new Direct3D.WriteTexture( device, size, size, DXGI.Format.R8G8B8A8_UNorm );
cache.Added += ( Page page, Point pt ) => quadtree.Add( page, pt );
cache.Removed += ( Page page, Point pt ) => quadtree.Remove( page );
SetupDataAndInfo();
}
public DepthBuffer( D3D10.Device device, int width, int height, DXGI.Format format )
{
this.device = device;
D3D10.Texture2DDescription desc = new D3D10.Texture2DDescription();
desc.Width = width;
desc.Height = height;
desc.ArraySize = 1;
desc.BindFlags = D3D10.BindFlags.DepthStencil;
desc.CpuAccessFlags = D3D10.CpuAccessFlags.None;
desc.Format = format;
desc.MipLevels = 1;
desc.OptionFlags = D3D10.ResourceOptionFlags.None;
desc.SampleDescription = new SlimDX.DXGI.SampleDescription( 1, 0 );
desc.Usage = D3D10.ResourceUsage.Default;
Resource = new D3D10.Texture2D( device, desc );
View = new D3D10.DepthStencilView( device, Resource );
}
public SimpleModel(Device device, string effectName, string meshName, Texture2D tex)
{
this.device = device;
effect = Effect.FromFile(device, effectName, "fx_4_0"); ;
LoadMesh(meshName);
elements = new[] {
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 0, 1),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 0, 2)
};
layout = new InputLayout(device, effect.GetTechniqueByIndex(0).GetPassByIndex(0).Description.Signature, elements);
SetTexture(tex);
binding = new[] {
new VertexBufferBinding(vertices, 12, 0),
new VertexBufferBinding(normals, 12, 0),
new VertexBufferBinding(texCoords, 8, 0)
};
}
public StagingTexture(Device device, Texture2DDescription desc)
: base(new Texture2D(device, desc))
{
}
private static void PrintDeviceInformation(Adapter adapter) {
using (var device = new Device(adapter, DriverType.Hardware, DeviceCreationFlags.None)) {
PrintSupportedFormats(device);
}
}
public DxKinectMeshRenderer(Device dxDevice)
{
_dxDevice = dxDevice;
LoadEffect(@"Assets\kinectpoints_mesh.fx");
}
public ResourceView(D3D.Device device)
{
this.device = device;
}
public void InitializeDevice()
{
mForm = new Form { Width = mWidth, Height = mHeight };
mForm.Closing += (sender, args) => IsClosing = true;
using (var factory = new Factory())
{
Device = new Device(factory.GetAdapter(0), DriverType.Hardware, DeviceCreationFlags.None);
mSwapChain = CreateSwapChain(factory);
}
using (var texture = Resource.FromSwapChain<Texture2D>(mSwapChain, 0))
{
mRenderTarget = new RenderTargetView(Device, texture);
}
var viewport = new Viewport
{
X = 0,
Y = 0,
Width = mWidth,
Height = mHeight,
MinZ = 0.0f,
MaxZ = 1.0f
};
SetRasterizerState();
CreateDepthBuffer();
CreateStencilState();
Device.Rasterizer.SetViewports(viewport);
Device.OutputMerger.SetTargets(mDepthStencilView, mRenderTarget);
}
public RenderTargetTexture(Device device, int width, int height)
: base(device, new Texture2D(device, CreateDescription(width, height)))
{
}
private Buffer CreateBuffer(Device device)
{
Vertex[] vertices = CreateVertices();
var stream = new DataStream(vertices.Length * Marshal.SizeOf(typeof(Vertex)), true, true);
foreach (var vertex in vertices)
{
stream.Write(vertex.Position);
stream.Write(vertex.Color);
stream.Write(vertex.Normal);
}
// Important: when specifying initial buffer data like this, the buffer will
// read from the current DataStream position; we must rewind the stream to
// the start of the data we just wrote.
stream.Position = 0;
var bufferDescription = new BufferDescription
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = (3 * Marshal.SizeOf(typeof(Vertex))),
Usage = ResourceUsage.Default
};
var buffer = new Buffer(device, stream, bufferDescription);
stream.Close();
return buffer;
}
public DxTextureManager(Device dxDevice)
{
_textures = new Dictionary<string, ShaderResourceView>();
_dxDevice = dxDevice;
}
public virtual void Render(Device device, ShaderHelper shaderHelper)
{
if (vertexBuffer != null && Topology != PrimitiveTopology.Undefined)
{
device.InputAssembler.SetInputLayout(vertexLayout);
device.InputAssembler.SetPrimitiveTopology(Topology);
device.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, Marshal.SizeOf(typeof(Vertex)), 0));
if (indexBuffer != null)
device.InputAssembler.SetIndexBuffer(indexBuffer, Format.R32_UInt, 0);
shaderHelper.ConstantBufferSet.World = World;
shaderHelper.ConstantBufferSet.LocalRotation = RotationMatrix;
shaderHelper.ConstantBufferSet.TextureIndex = TextureIndex;
shaderHelper.ApplyEffects();
if (indexBuffer != null)
device.DrawIndexed(Vertices.NumElements, 0, 0);
else
{
device.Draw(Vertices.NumElements, 0);
}
}
}
public virtual void Update(Device device, ShaderSignature effectSignature)
{
if (device != null && !device.Disposed)
{
mDevice = device;
mSignature = effectSignature;
// If there is less than 1 vertex then we can't make a point, let alone a shape!
if (Vertices != null && Vertices.Count > 0)
{
CalculatePreTransformBoundingBox();
// Add Vertices to a datastream.
using (DataStream dataStream = new DataStream(Vertices.NumBytes, true, true))
{
dataStream.WriteRange(this.Vertices.ToArray());
dataStream.Position = 0;
// Create a new data buffer description and buffer
BufferDescription desc = new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = Vertices.NumBytes,
Usage = ResourceUsage.Default
};
if (vertexBuffer != null)
vertexBuffer.Dispose();
vertexBuffer = new SlimDX.Direct3D10.Buffer(device, dataStream, desc);
//dataStream.Close();
}
if (Vertices != null && Vertices.Count > 0)
{
// Set the input layout.
InputElement[] inputElements = Vertices[0].GetInputElements();
if (vertexLayout != null)
vertexLayout.Dispose();
vertexLayout = new InputLayout(device, effectSignature, inputElements);
// Draw Indexed
if (Vertices.Indices != null && Vertices.Indices.Count > 0)
{
using (DataStream iStream = new DataStream(sizeof(int) * Vertices.Indices.Count, true, true))
{
iStream.WriteRange(Vertices.Indices.ToArray());
iStream.Position = 0;
BufferDescription desc = new BufferDescription()
{
Usage = ResourceUsage.Default,
SizeInBytes = sizeof(int) * Vertices.Indices.Count,
BindFlags = BindFlags.IndexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
if (indexBuffer != null)
indexBuffer.Dispose();
indexBuffer = new Buffer(device, iStream, desc);
//iStream.Close();
}
}
else
{
if (indexBuffer != null) indexBuffer.Dispose();
indexBuffer = null;
}
}
else
{
if (vertexBuffer != null) vertexBuffer.Dispose();
vertexBuffer = null;
}
}
}
FireShapeChangeEvent(new ShapeChangeEventArgs(this, ShapeChangeEventArgs.ChangeAction.None));
}
public override void Hook()
{
this.DebugMessage("Hook: Begin");
// Determine method addresses in Direct3D10.Device, and DXGI.SwapChain
if (_d3d10VTblAddresses == null)
{
_d3d10VTblAddresses = new List<IntPtr>();
_dxgiSwapChainVTblAddresses = new List<IntPtr>();
this.DebugMessage("Hook: Before device creation");
using (SlimDX.DXGI.Factory factory = new SlimDX.DXGI.Factory())
{
using (SlimDX.Direct3D10.Device device = new Device(factory.GetAdapter(0), DriverType.Hardware, DeviceCreationFlags.None))
{
this.DebugMessage("Hook: Device created");
_d3d10VTblAddresses.AddRange(GetVTblAddresses(device.ComPointer, D3D10_DEVICE_METHOD_COUNT));
using (SlimDX.Windows.RenderForm renderForm = new SlimDX.Windows.RenderForm())
{
using (SlimDX.DXGI.SwapChain sc = new SlimDX.DXGI.SwapChain(factory, device, DXGI.CreateSwapChainDescription(renderForm.Handle)))
{
_dxgiSwapChainVTblAddresses.AddRange(GetVTblAddresses(sc.ComPointer, DXGI.DXGI_SWAPCHAIN_METHOD_COUNT));
}
}
}
}
}
// We will capture the backbuffer here
DXGISwapChain_PresentHook = LocalHook.Create(
_dxgiSwapChainVTblAddresses[(int)DXGI.DXGISwapChainVTbl.Present],
new DXGISwapChain_PresentDelegate(PresentHook),
this);
// We will capture target/window resizes here
DXGISwapChain_ResizeTargetHook = LocalHook.Create(
_dxgiSwapChainVTblAddresses[(int)DXGI.DXGISwapChainVTbl.ResizeTarget],
new DXGISwapChain_ResizeTargetDelegate(ResizeTargetHook),
this);
/*
* Don't forget that all hooks will start deactivated...
* The following ensures that all threads are intercepted:
* Note: you must do this for each hook.
*/
DXGISwapChain_PresentHook.ThreadACL.SetExclusiveACL(new Int32[1]);
DXGISwapChain_ResizeTargetHook.ThreadACL.SetExclusiveACL(new Int32[1]);
}
