Jump to content

  • Log In with Google      Sign In   
  • Create Account

We're offering banner ads on our site from just $5!

1. Details HERE. 2. GDNet+ Subscriptions HERE. 3. Ad upload HERE.


Member Since 24 Oct 2008
Offline Last Active Dec 13 2012 06:43 PM

#5008089 SlimDX Directx11 Text Rendering Problem

Posted by Megafont on 07 December 2012 - 05:31 AM

Ok, I have been following the tutorials on braynzarsoft.net, but using SlimDX. I am currently stuck on tutorial #14 which is about rendering text on the screen. But you have to go through all this bs of creating a D3D10 device, and using D2D and DirectWrite, just to get text on the screen. Anyway, I have the code in and the compiler is happy with it, except for one detail. The tutorial says that you MUST set the DriverType for the D3D11 device, to DriverType.Unknown. But anytime I set it to that, it is an automatic fail with an invalid arg error from the CreateDeviceWithSwapChain() method. So how is it that I am supposed to set it to DriverType.Unknown if it simply hates that value for that parameter?

If I leave it set to DriverType.Hardware, the program will run and draw a triangle on the screen like it is supposed to, but the text is nowhere to be seen. I have no idea what the problem is.

The tutorial I am following is here:

Here is the code of my class that handles the text rendering. I made it a separate class because it would clutter up the main gamewindow class since you have to do this rediculous pile of crap just to get text on the screen.
	public class TextRenderer_D2D_DW : IDisposable
		#region Constants

		#region Member Variables
		SlimDX.Windows.RenderForm m_ParentWindow = null;
		SlimDX.Direct3D10_1.Device1 m_d3d101_Device = null;
		SlimDX.Direct3D11.Device m_d3d11_Device = null;
		KeyedMutex m_keyedMutex_d3d11 = null;
		KeyedMutex m_keyedMutex_d3d10 = null;
		SlimDX.Direct2D.RenderTarget m_d2dRenderTarget = null;		  // A RenderTarget for D2D to draw on.
		SlimDX.Direct2D.SolidColorBrush m_d2dBrush = null;			  // The Brush D2D will draw with.
		//SlimDX.Direct3D11.Texture2D m_backBuffer_d3d11 = null;
		SlimDX.Direct3D11.Texture2D m_sharedTexture_d3d11 = null;	   // The shared texture that we will have D2D/DW render onto, and then have D3D overlay this texture onto our scene.
		SlimDX.Direct3D11.Buffer m_d2dVertexBuffer = null;			  // The vertex buffer for the square to render the text texture onto.
		SlimDX.Direct3D11.Buffer m_d2dIndexBuffer = null;			   // The index buffer for the square to render the text texture onto.
		SlimDX.Direct3D11.ShaderResourceView m_textTexture = null;	  // The ShaderResourceView for the text texture.
		BlendState m_BlendState_Transparency = null;					// Our transparency blending state.
		RasterizerState m_RasterizerState_CWcullmode = null;			// for clockwise culling
		SamplerState m_TextSamplerState = null;						 // our SamplerState
		SlimDX.DirectWrite.Factory m_DWrite_Factory = null;			 // A DirectWrite Factory.
		SlimDX.DirectWrite.TextFormat m_DWrite_TextFormat = null;	   // Holds our text format settings, such as font, size, etc.
		// These hold references to the passed int ConstantBuffers.
		ConstantBuffer_ChangesOnResize m_cbOnResize = null;			
		ConstantBuffer_ChangesPerFrame m_cbPerFrame = null;
		ConstantBuffer_ChangesPerObject m_cbPerObject = null;

		int m_nVertexBufferStride = 0;   // Stores the stride (number of bytes per vertex) in our vertex buffer.
		// Shaders
		VertexShader m_vShader = null;
		ShaderSignature m_vShaderSignature = null;
		PixelShader m_pShader = null;

		bool m_bIsInitialized = false;   // Indicates whether this object is initialized or not.
		bool m_bDisposed = false;		// Indicates whether this object has been disposed or not.

		#region Constructors
		public TextRenderer_D2D_DW(SlimDX.Windows.RenderForm form, SlimDX.Direct3D11.Device d3d11_device, ConstantBuffer_ChangesOnResize cbOnResize, ConstantBuffer_ChangesPerFrame cbPerFrame, ConstantBuffer_ChangesPerObject cbPerObject)
			if (form == null)
				throw new Exception("The passed in form parameter is null!");
			this.m_ParentWindow = form;
			if (d3d11_device == null)
				throw new Exception("The passed in Direct3D 11 device is null!");
			this.m_d3d11_Device = d3d11_device;
			if (cbOnResize == null)
				throw new Exception("The first passed in constant buffer object is null!");
			this.m_cbOnResize = cbOnResize;
			if (cbPerFrame == null)
				throw new Exception("The second passed in constant buffer object is null!");
			this.m_cbPerFrame = cbPerFrame;
			if (cbPerObject == null)
				throw new Exception("The third passed in constant buffer object is null!");
			this.m_cbPerObject = cbPerObject;
			// Set up our Transparency blending state.
			// ----------------------------------------------------------------------------------------
			// Create our RenderTargetBlendDescription.
			RenderTargetBlendDescription rtbd = new RenderTargetBlendDescription();
			rtbd.BlendEnable = true;
			rtbd.SourceBlend = BlendOption.SourceColor;
			rtbd.DestinationBlend = BlendOption.InverseSourceAlpha;
			rtbd.BlendOperation = BlendOperation.Add;
			rtbd.SourceBlendAlpha = BlendOption.One;
			rtbd.DestinationBlendAlpha = BlendOption.Zero;
			rtbd.BlendOperationAlpha = BlendOperation.Add;
			rtbd.RenderTargetWriteMask = ColorWriteMaskFlags.All;
			// Create our BlendStateDescription.
			BlendStateDescription bsd = new BlendStateDescription();
			bsd.AlphaToCoverageEnable = false;
			bsd.RenderTargets[0] = rtbd;
			// Create our BlendState.
			m_BlendState_Transparency = BlendState.FromDescription(m_d3d11_Device, bsd);

			// Set up a RasterizerState for Clockwise culling mode.
			// ----------------------------------------------------------------------------------------
			// Create our RasterizerStateDescription
			RasterizerStateDescription rsd = new RasterizerStateDescription();
			rsd.FillMode = SlimDX.Direct3D11.FillMode.Solid;
			rsd.CullMode = CullMode.Back;
			// Create the Clockwise cull mode state.
			rsd.IsFrontCounterclockwise = false;
			m_RasterizerState_CWcullmode = RasterizerState.FromDescription(m_d3d11_Device, rsd);

			// Set up a SamplerState that we will use for Rendering our text.
			// ----------------------------------------------------------------------------------------
			// Create a SamplerDescription
			SamplerDescription sd = new SamplerDescription();
			sd.Filter = Filter.MinMagMipLinear;
			sd.AddressU = TextureAddressMode.Wrap;
			sd.AddressV = TextureAddressMode.Wrap;
			sd.AddressW = TextureAddressMode.Wrap;
			sd.ComparisonFunction = Comparison.Never;
			sd.MinimumLod = 0;
			sd.MaximumLod = float.MaxValue;
			// Create our SamplerState
			m_TextSamplerState = SamplerState.FromDescription(m_d3d11_Device, sd);

			m_bIsInitialized = true;

		#region Non-Public Methods
		// This section is for methods that are declared as private, protected, protected internal, or internal.

		private bool InitD2D_D3D101_DWrite()
			// Create our Direct3D 10.1 Device
			m_d3d101_Device = new SlimDX.Direct3D10_1.Device1(m_d3d11_Device.Factory.GetAdapter(0),
															  SlimDX.Direct3D10.DeviceCreationFlags.BgraSupport | SlimDX.Direct3D10.DeviceCreationFlags.Debug,

			// Create the Shared Texture that Direct3D 10.1 will render on
			SlimDX.Direct3D11.Texture2DDescription sharedTexDesc = new Texture2DDescription();
			sharedTexDesc.Width = m_ParentWindow.ClientSize.Width;
			sharedTexDesc.Height = m_ParentWindow.ClientSize.Height;
			sharedTexDesc.Format = Format.B8G8R8A8_UNorm;
			sharedTexDesc.MipLevels = 1;
			sharedTexDesc.ArraySize = 1;
			sharedTexDesc.SampleDescription = new SampleDescription(1, 0);
			sharedTexDesc.Usage = ResourceUsage.Default;
			sharedTexDesc.BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget;
			sharedTexDesc.OptionFlags = ResourceOptionFlags.KeyedMutex;
			m_sharedTexture_d3d11 = new Texture2D(m_d3d11_Device, sharedTexDesc);

			// Get the keyed mutex for the shared texture (for Direct3D 11)
			m_keyedMutex_d3d11 = new KeyedMutex(m_sharedTexture_d3d11);
			m_keyedMutex_d3d11.Acquire(0, 5);
			// Get the resource for the shared texture.
			SlimDX.DXGI.Resource r = new SlimDX.DXGI.Resource(m_sharedTexture_d3d11);
			// Open the surface for the shared texture in Direct3D 10.1.
			SlimDX.Direct3D10.Texture2D sharedTexture10;
			sharedTexture10 = m_d3d101_Device.OpenSharedResource<SlimDX.Direct3D10.Texture2D>(r.SharedHandle);
			m_keyedMutex_d3d10 = new KeyedMutex(sharedTexture10);
			// Create the Direct2D factory
			SlimDX.Direct2D.Factory d2dFactory = new SlimDX.Direct2D.Factory(SlimDX.Direct2D.FactoryType.SingleThreaded);
			SlimDX.Direct2D.RenderTargetProperties d2d_rtp = new RenderTargetProperties();
			d2d_rtp.Type = RenderTargetType.Hardware;
			d2d_rtp.PixelFormat = new PixelFormat(Format.Unknown, AlphaMode.Premultiplied);
			m_d2dRenderTarget = RenderTarget.FromDXGI(d2dFactory, sharedTexture10.AsSurface(), d2d_rtp);
			// Create a solid color brush to draw something with.
			m_d2dBrush = new SolidColorBrush(m_d2dRenderTarget, new Color4(1.0f, 1.0f, 0.0f, 1.0f));

			// DirectWrite
			m_DWrite_Factory = new SlimDX.DirectWrite.Factory(SlimDX.DirectWrite.FactoryType.Shared);
			m_DWrite_TextFormat = m_DWrite_Factory.CreateTextFormat("Arial",
			m_DWrite_TextFormat.TextAlignment = TextAlignment.Leading;
			m_DWrite_TextFormat.ParagraphAlignment = ParagraphAlignment.Near;
			// This is to prevent an annoying warning that pops up if you haven't set the primitive topology.

			return true;

		void InitD2DScreenTexture()
			VertexList<Vertex3D_T> vList = new VertexList<Vertex3D_T>(m_d3d11_Device);
			vList.AddVertex(new Vertex3D_T(-1.0f, -1.0f, 1.0f, 0.0f, 1.0f));
			vList.AddVertex(new Vertex3D_T(-1.0f,  1.0f, 1.0f, 0.0f, 0.0f));
			vList.AddVertex(new Vertex3D_T( 1.0f,  1.0f, 1.0f, 1.0f, 0.0f));
			vList.AddVertex(new Vertex3D_T( 1.0f, -1.0f, 1.0f, 1.0f, 1.0f));
			// Create the vertex buffer now that we've defined all the vertex data.
			vList.CreateVertexBuffer(out m_d2dVertexBuffer);
			m_nVertexBufferStride = vList.VertexSize;

			IndexList<UInt16> iList = new IndexList<UInt16>(m_d3d11_Device);
			// Front Face
			iList.AddIndices(0, 1, 2,
							 0, 2, 3);

			// Create the index buffer now that we've defined all the index data.
			iList.CreateIndexBuffer(out m_d2dIndexBuffer);
			// Create a ShaderResourceView from the texture D2D will render to,
			// So we can use it to texture a square which overlays our scene.
			m_textTexture = new ShaderResourceView(m_d3d11_Device, m_sharedTexture_d3d11);

		void InitShaders()
			string shaderCode = "";

			// The file TextRenderer_D2D_DW is an embedded resource.  So we need to access it and put it in a string variable first.
			using (Stream stream = Assembly.GetExecutingAssembly()
				using (StreamReader reader = new StreamReader(stream))
					shaderCode = reader.ReadToEnd();

			// load and compile the vertex shader
			string vsCompileError = "TextRenderer_D2D_DW - Vertex Shader Compile Error!!!";
			using (var bytecode = ShaderBytecode.Compile(shaderCode, "Text_VS", "vs_4_0", ShaderFlags.Debug, EffectFlags.None, null, null, out vsCompileError))
				m_vShaderSignature = ShaderSignature.GetInputSignature(bytecode);
				m_vShader = new VertexShader(m_d3d11_Device, bytecode);
			// load and compile the pixel shader
			string psCompileError = "TextRenderer_D2D_DW - Pixel Shader Compile Error!!!";
			using (var bytecode = ShaderBytecode.Compile(shaderCode, "Text_PS", "ps_4_0", ShaderFlags.Debug, EffectFlags.None, null, null, out psCompileError))
				m_pShader = new PixelShader(m_d3d11_Device, bytecode);

		#region Public Methods
		public void RenderString(string text)
			if (!m_bIsInitialized)

			BlendState blendState = null;
			RasterizerState rasterizerState = null;
			SamplerState samplerState = null;
			VertexShader vertexShader = null;
			PixelShader pixelShader = null;

			// Save the current states so we can reset them when we're done with them.
			blendState = m_d3d11_Device.ImmediateContext.OutputMerger.BlendState;
			rasterizerState = m_d3d11_Device.ImmediateContext.Rasterizer.State;
			samplerState = m_d3d11_Device.ImmediateContext.PixelShader.GetSamplers(0, 1)[0]; // We only take the first SamplerState since its the only one we will change when we render the text texture to the back buffer below.
			vertexShader = m_d3d11_Device.ImmediateContext.VertexShader.Get();
			pixelShader = m_d3d11_Device.ImmediateContext.PixelShader.Get();

			// Release the shared texture from the D3D 11 Device.
			// Aquire the shared texture with the D3D 10.1 Device.
			m_keyedMutex_d3d10.Acquire(0, int.MaxValue);
			// Begin drawing Direct2D content.

			// Clear the D2D Background
			m_d2dRenderTarget.Clear(new Color4(1.0f, 0.0f, 0.0f, 0.0f));

			// Set the Font Color
			Color4 FontColor = new Color4(1.0f, 1.0f, 1.0f, 1.0f);
			// Set the brush color D2D will use to draw with.
			m_d2dBrush.Color = FontColor;
			// Create the D2D render area
			System.Drawing.RectangleF layoutRect = new System.Drawing.RectangleF(0, 0, m_ParentWindow.ClientSize.Width, m_ParentWindow.ClientSize.Height);

			// Draw the Text onto the shared texture.
			// Finish drawing Direct2D content.

			// Release the shared texture from the Direct3D 10.1 Device.
			// Aquire the shared texture with the Direct3D 11 Device.
			m_keyedMutex_d3d11.Acquire(1, int.MaxValue);
			// Use the shader resource representing the Direct2D render target
			// to texture a square which is rendered in screen space so it
			// overlays on top of our entire scene. We use alpha blending so
			// that the entire background of the D2D render target is "invisible",
			// And only the stuff we draw with D2D will be visible (the text)

			// Set the blending state of the Direct3D 11 device.
			m_d3d11_Device.ImmediateContext.OutputMerger.BlendState = m_BlendState_Transparency;

			// Set the vertex buffer for the text geometry (a square).
			m_d3d11_Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new SlimDX.Direct3D11.VertexBufferBinding(m_d2dVertexBuffer, 20, 0));
			// Set the index buffer for the text geometry.
			m_d3d11_Device.ImmediateContext.InputAssembler.SetIndexBuffer(m_d2dIndexBuffer, Format.R16_UInt, 0);

			// Set the vertex shader to the one this TextRenderer uses.
			// Set the pixel shader to the one this TextRenderer uses.

			// Set the world matrix to the Indentity Matrix.
			Matrix tempP = m_cbOnResize.ProjectionMatrix;
			Matrix tempV = m_cbPerFrame.ViewMatrix;
			Matrix tempW = m_cbPerObject.WorldMatrix;
			m_cbOnResize.ProjectionMatrix = Matrix.Identity;
			m_cbPerFrame.ViewMatrix = Matrix.Identity;
			m_cbPerObject.WorldMatrix = Matrix.Identity;

			// Set the RasterizerState to our Clockwise Cull mode one.
			m_d3d11_Device.ImmediateContext.Rasterizer.State = m_RasterizerState_CWcullmode;
			// Set the shader resource (our shared text texture).
			m_d3d11_Device.ImmediateContext.PixelShader.SetShaderResource(m_textTexture, 0);
			// Set the SamplerState.
			m_d3d11_Device.ImmediateContext.PixelShader.SetSampler(m_TextSamplerState, 0);
			// Draw the text texture overlay on top of our scene.
			m_d3d11_Device.ImmediateContext.DrawIndexed(6, 0, 0);
			// Reset the vertex shader.
			// Reset the pixel shader.
			// Reset the states of the Direct3D 11 Device now that we are done with them.
			// This way we leave the device how we found it for the parent program.
			m_d3d11_Device.ImmediateContext.OutputMerger.BlendState = blendState;
			m_d3d11_Device.ImmediateContext.Rasterizer.State = rasterizerState;
			m_d3d11_Device.ImmediateContext.PixelShader.SetSampler(samplerState, 0);

			// Reset the ConstantBuffers as well.
			m_cbPerFrame.ViewMatrix = tempV;
			m_cbOnResize.ProjectionMatrix = tempP;
			m_cbPerObject.WorldMatrix = tempW;

		#region Operators

		#region IDisposable Members
		// Implement IDisposable.
		// Do not make this method virtual.
		// A derived class should not be able to override this method.
		public void Dispose()
			// Since this Dispose() method already cleaned up the resources used by this object, there's no need for the
			// Garbage Collector to call this class's Finalizer, so we tell it not to.
		protected void Dispose(bool disposing)
			if (!this.m_bDisposed)
				* The following text is from MSDN  (http://msdn.microsoft.com/en-us/library/fs2xkftw%28VS.80%29.aspx)
				* Dispose(bool disposing) executes in two distinct scenarios:
				* If disposing equals true, the method has been called directly or indirectly by a user's code and managed and unmanaged resources can be disposed.
				* If disposing equals false, the method has been called by the runtime from inside the finalizer and only unmanaged resources can be disposed.
				* When an object is executing its finalization code, it should not reference other objects, because finalizers do not execute in any particular order.
				* If an executing finalizer references another object that has already been finalized, the executing finalizer will fail.
				if (disposing)
					// Unregister events

					// get rid of managed resources
					m_ParentWindow = null;  // We don't release this since it was created by the parent program.
					m_d3d11_Device = null;  // This was also created by the parent program.
				// get rid of unmanaged resources


		#region Debug Methods
#if (DEBUG)
		// put all debug methods in here...

		#region Properties
		/// <summary>
		/// Returns a boolean value indicating whether or not this object has been disposed.
		/// </summary>
		public bool IsDisposed
				return m_bDisposed;
		/// <summary>
		/// Returns a boolean value indicating whether the GameWindow has finished initializing itself yet or not.
		/// </summary>
		virtual public bool IsInitialized
				return m_bIsInitialized;

		#region Events

		#region Event Handlers

I'm fairly sure the problem is somewhere in this class, but I have no idea what is wrong. I get no evidence that the text renderer class is doing anything at all. It has no effect on the output. And its quite difficult to debug these applications because you either get stupid vague error messages, or other nonsense. I can't use the DirectX Graphics Diagnostics tools in VS2012, because of course they don't support using D2D with DX11. This is quite a nasty big mess Microsoft has made for us...

And here is the shader code being used by the text renderer in case the problem lies there. I've mucked with this a lot too but no luck. I changed the pixel shader to output black no matter what so I could at least see if it is drawing something, but I still get nothing.
cbuffer cbPerResize : register( b0 )
matrix Projection;
cbuffer cbPerFrame : register( b1 )
matrix View;
cbuffer cbPerObject : register( b2 )
matrix World;
Texture2D ObjTexture;
SamplerState ObjSamplerState;

struct VS_OUTPUT
    float4 Pos : SV_POSITION;
float2 TexCoord : TEXCOORD;

VS_OUTPUT Text_VS(float4 inPos : POSITION, float2 inTexCoord : TEXCOORD)
    VS_OUTPUT output = (VS_OUTPUT)0;

matrix identity;
identity[0] = float4(1,0,0,0);
identity[1] = float4(0,1,0,0);
identity[2] = float4(0,0,1,0);
identity[3] = float4(0,0,0,1);

output.Pos = mul(inPos, identity);
    output.Pos = mul( inPos, World );
    output.Pos = mul( output.Pos, View );
    output.Pos = mul( output.Pos, Projection );
output.TexCoord = inTexCoord;
    return output;
float4 Text_PS(VS_OUTPUT input) : SV_TARGET
    //return ObjTexture.Sample( ObjSamplerState, input.TexCoord );
return float4(0.0f, 0.0f, 0.0f, 0.0f);

This is just irritating because I've wasted the whole night trying to get this to work and I'm rather tired of microsoft and their bs. It is utterly rediculous that one has to go through all this crap just to get some lousy text on the screen...

Can anyone help me, I hope? And thank you so much for your time!