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 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(); }
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]); }