What is the most efficient method of rendering sprites in DirectX 10?

Question

I am currently experimenting with various ways of displaying 2D sprites in DirectX 10. I began by using the ID3DX10Sprite interface to batch draw my sprites in a single call. Eventually, however, I wanted a little more control over how my sprites were rendered, so I decided to look into quad-based sprite rendering (ie each sprite being represented by a quad with a texture applied).

I started out simple: I created a single vertex buffer consisting of 4 vertices that was applied once before the sprites were drawn. I then looped through my sprites, setting the appropriate properties to be passed into the shader, and making a draw call for each sprite, like so: d3dDevice->Draw( 4, 0);. Though it worked, the draw call for every sprite bugged me, so I looked for a more efficient method.

After searching about, I learned about object instancing, and decided to try it out. Everything went well until I tried implementing the most important part of sprites--textures. In short, though I had a texture array (declared at the top of my shader like so Texture2D textures[10];) that could be successfully sampled within my pixel shader using literals/constants as indexes, I could not figure out how to control which textures were applied to which instances via a texture index.

The idea would be for me to pass in a texture index per instance, that could then be used to sample the appropriate texture in the array within the pixel shader. However, after searching around more, I could not find an example of how it could be done (and found many things suggesting that it could not be done without moving to DirectX 11).

Is that to say that the only way to successfully render sprites via object instancing in DirectX 10 is to render them in batches based on texture? So, for example, if my scene consists of 100 sprites with 20 different textures (each texture referenced by 5 sprites), then it would take 20 separate draw calls to display the scene, and I would only be sending 5 sprites at a time.

In the end, I am rather at a loss. I have done a lot of searching, and seem to be coming up with conflicting information. For example, in this article in paragraph 6 it states:

Using DirectX 10, it is possible to apply different textures in the array to different instances of the same object, thus making them look different

In addition, on page 3 of this whitepaper, it mentions the option to:

Read a custom texture per instance from a texture array

However, I cannot seem to find a concrete example of how the shader can be setup to access a texture array using a per instance texture index.

In the end, the central question is: What is the most efficient method of rendering sprites using DirectX 10?

If the answer is instancing, then is it possible to control which texture is applied to each specific instance within the shader--thereby making it possible to send in much larger batches of sprites along with their appropriate texture index with only a single draw call? Or must I be content with only instancing sprites with the same texture at a time?

If the answer is returning to the use of the provided DX10 Sprite interface, then is there a way for me to have more control over how it is rendered?

As a side note, I have also looked into using a Geometry Shader to create the actual quad, so I would only have to pass in a series of points instead of managing a vertex and instance buffer. Again, though, unless there is a way to control which textures are applied to the generated quads, then I'm back to only batching sprites by textures.

Answer 1

There's a few ways (as usual) to do what you describe.

Please note that using

Texture2D textures[10];

will not allow you to use a variable index for lookup in Pixel Shader (since technically this declaration will allocate a slot per texture).

So what you need is to create a Texture2DArray instead. This is a bit like a volume texture, but the z component is a full number and there's no sampling on it.

You will need to generate this texture array though. Easy way is on startup you do one full screen quad draw call to draw each texture into a slice of the array (you can create a RenderTargetView for a specific slice). Shader will be a simple passtrough here.

To create a Texture Array (code is in SlimDX but, options are similar):

 var texBufferDesc = new Texture2DDescription
  {
            ArraySize = TextureCount,
            BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
            CpuAccessFlags = CpuAccessFlags.None,
            Format = format,
            Height = h,
            Width = w,
            OptionFlags = ResourceOptionFlags.None,
            SampleDescription = new SampleDescription(1,0),
            Usage = ResourceUsage.Default,
 };

Then shader resource view is like this:

  ShaderResourceViewDescription srvd = new ShaderResourceViewDescription()
  {
      ArraySize = TextureCount,
      FirstArraySlice = 0,
      Dimension = ShaderResourceViewDimension.Texture2DArray,
      Format = format,
      MipLevels = 1,
      MostDetailedMip = 0
  };

Finally, to get a render target for a specific slice:

 RenderTargetViewDescription rtd = new RenderTargetViewDescription()
 {
      ArraySize = 1,
      FirstArraySlice = SliceIndex,
      Dimension = RenderTargetViewDimension.Texture2DArray,
      Format = this.Format
 };

Bind that to your passtrough shader, set desired texture as input and slice as output and draw a full screen quad (or full screen triangle).

Please note that this texture can also be saved in dds format (so it saves you to regenerate every time you start your program).

Looking up your Texture is like:

Texture2DArray myarray;

In Pixel Shader:

myarray.Sample(mySampler, float2(uv,SliceIndex);

Now about rendering sprites, you also have the option of GS expansion.

So you create a vertex buffer containing only the position/size/textureindex/whatever else you need one one vertex per sprite.

Send a draw call with n sprites (Topology needs to be set to point list).

Passtrough the data from vertex shader to geometry shader.

Expand your point into quad in geometry shader, you can find an example which is ParticlesGS in Microsoft SDK doing that, it's a bit overkill for your case since you only need the rendering part for it, not the animation. If you need some cleaned code let me know I'll quickly make a dx10 compatible sample (In my case I use StructuredBuffers instead of VertexBuffer)

Doing a pre-made Quad and passing the above data in Per Instance VertexBuffer is also possible, but if you have a high number of sprites it will easily blow up your graphics card (by high I mean something like over 3 million particles, which is not much by nowadays standards, but if you're under half a million sprites you'll be totally fine ;)

Answer 2

Include the texture index within the instance buffer and use this to select the correct texture from the texture array per instance:

struct VS
{
    float3 Position: POSITION;
    float2 TexCoord: TEXCOORD0;
    float  TexIndex: TexIndex; // From the instance buffer not the vertex buffer
}

Then pass this value on through to the pixel shader

struct PS
{
    float4 Positon: SV_POSITION;
    float3 TexCoord: TEXCOORD0;
}

..

vout.TexCoord = float3(vin.TexCoord, vin.TexIndex);