When being organized in Unity 3D is dangerous

While adding Prime31′s Android In-App Billing to an existing game I came across a weird behavior: the calls to the native plugin (made through the GoogleIAB class) were being registered but the callback events (the ones defined in GoogleIABManager) weren’t firing.

After half a day of looking at Android’s documentation, browsing the existing knowledge base and trying different things I found the problem: in a previous refactor I had modified the source files provided by the plugin to put the classes inside a custom namespace. Apparently the reflection methods internally used by the plugin don’t like this and it failed silently. No indication that the type couldn’t be found, failed instancing or the methods didn’t exist.

Morale of this story is to never modify the source code of existing Unity 3D plugins as they usually are quite weak and can break, so whenever you install something from the Asset Store make sure you don’t modify it. In case someone ever has the same problem I added it to the official knowledge base.

Drawing text with Direct2D and DirectWrite with SharpDX

Back when Windows 7 was launched, DirectX 11 introduced a new API for text rendering called DirectWrite. It was intended as a fresh start from the old GDI implementation, featuring full unicode support, ClearType text rendering, OpenType typographic features and much more. One of the advantages of DirectWrite is that although it is a DirectX API, it has been architectured as a standalone component with no dependency on any of the existing rendering ones, meaning that you can use it from Direct3D, Direct2D or even your own custom renderer. As an example of its independence, since version 4 the web browser Mozilla Firefox uses DirectWrite on supported platforms for text rendering.

This tutorial is based on the previous one about basic Direct2D initialization and drawing so go ahead and clone the source code from GitHub if you haven’t done it already.


This is very simple. We just instantiate a new SharpDX.DirectWrite.Factory object, which doesn’t need any parameters unless you want to specify if it will be a shared factory to be used across different threads.

DirectWrite factory initialization
  1. // Create the DirectWrite factory object.
  2. SharpDX.DirectWrite.Factory fontFactory = new SharpDX.DirectWrite.Factory();


Now it’s time to create the objects that will contain the neccessary information for drawing text.

  • TextFormat is an object that will hold a font’s family, size and other properties like style and weight. We will be using Segoe UI with a size of 24 DIPs and normal weight and style. Note that the font is specified by its family name; in case it isn’t found no errors will be thrown, instead falling back to a default one.
  • TextLayout is a way of arranging a specified string of text inside a rectangle for further drawing. We will be creating two of them for demonstrating the different methods of rendering moving text.
TextFormat and TextLayout creation
  1. // Create a TextFormat object that will use the Segoe UI font with a size of 24 DIPs.
  2. textFormat = new TextFormat(fontFactory, “Segoe UI”, 24.0f);
  3. // Create two TextLayout objects for rendering the moving text.
  4. textLayout1 = new TextLayout(fontFactory, “This is an example of a moving TextLayout object with snapped pixel boundaries.”, textFormat, 400.0f, 200.0f);
  5. textLayout2 = new TextLayout(fontFactory, “This is an example of a moving TextLayout object with no snapped pixel boundaries.”, textFormat, 400.0f, 200.0f);


Drawing text is quite straightforward. Since the Direct2D DeviceContext object already has functions to render text using DirectWrite objects, we won’t need to roll out our own glyph rasterizer. Just a one line call to SharpDX.Direct2D1.DeviceContext.DrawText inside a BeginDraw/EndDraw block will output our text on screen.

Here we are going to draw two lines of text with a predefined layout region. The difference is that the first one will be clipped to that region (DrawTextOptions.Clip) while the second one won’t (DrawTextOptions.None).

Drawing normal and clipped text
  1. // Draw a block of text that will be clipped against the specified layout rectangle.
  2. d2dContext.FillRectangle(new RectangleF(50, 50, 200, 200), backgroundBrush);
  3. d2dContext.DrawText(“This text is long enough to overflow the designed region but will be clipped to the containing rectangle. Lorem ipsum dolor sit amet, consectetur adipiscing elit. “, textFormat, newRectangleF(50, 50, 200, 200), textBrush, DrawTextOptions.Clip);
  4. // Draw a block of text that will overflow the specified layout rectangle.
  5. d2dContext.FillRectangle(new RectangleF(50, 300, 200, 200), backgroundBrush);
  6. d2dContext.DrawText(“However, this other text isn’t going to be clipped: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean gravida dui id accumsan dictum.”, textFormat, new RectangleF(50, 300, 200, 200), textBrush, DrawTextOptions.None);


In case you want the text to appear crisper or more blurred, you can specify different measuring modes when calling DrawText:

  • Natural: Measures the text using the ideal glyph metrics, without taking into account the current screen resolution. This is the default value in case it’s not specified.
  • GdiClassic: Adjusts the glyph’s metrics based on the current display resolution.
  • GdiNatural: Again takes into account the display resolution but treats the font as if it was used for ClearType rendering.

The following image is a capture of the sample with a 400x zoom. Each line is drawn using Natural, GdiClassic and GdiNatural. Note that Natural measuring mode leaves less gap between each glyph. Click the image to view at full size.

MeasuringMode comparison

Now, let’s see how we can draw TextLayout objects. We just have to call SharpDX.Direct2D1.DeviceContext.DrawTextLayout, and since the font and string information are already stored in the TextLayout, we only need to specify the position, parameter and text brush. Using DrawTextLayout instead of DrawText is recommended since DrawText always creates a new TextLayout object internally, thus generating extra garbage.

In the following code, we are drawing two similar TextLayout blocks that move vertically. The difference is that the second one uses DrawTextOptions.NoSnap so the glyphs aren’t snapped to an integer position, allowing for subpixel movement and giving an smoother effect.

Drawing moving TextLayout
  1. // Draw moving text.
  2. d2dContext.FillRectangle(new RectangleF(300, 300, 400, 200), backgroundBrush);
  3. d2dContext.DrawTextLayout(new Vector2(300, 350 + layoutYOffset), textLayout1, textBrush);
  4. // Draw moving text without pixel snapping, thus giving a smoother movement.
  5. d2dContext.FillRectangle(new RectangleF(750, 300, 400, 200), backgroundBrush);
  6. d2dContext.DrawTextLayout(new Vector2(750, 350 + layoutYOffset), textLayout2, textBrush, DrawTextOptions.NoSnap);


Note that in the following animated image, the left text’s movement (disregarding minor encoding errors) is more jerky.


That’s it, we have learned how to do basic text drawing with SharpDX. You can get the finished source code from the corresponding GitHub repository.


SharpDX samples updated

In the hope of resuming the series of SharpDX articles that I started writing nearly two years ago, the existing ones (Your first DirectX 11 Metro application using SharpDX and Basic Direct2D drawing with SharpDX) have been updated to Visual Studio 2012 and SharpDX 2.5.0. And as a bonus, the source code has been migrated from a single CodePlex project to separate GitHub repositories. You can find the basic SharpDX tutorial here and the Direct2D one here.