Simple rendering

Here we learn how to render a triangle and a grid in 3D.

Setup

First create a new project using the instructions from the first two lessons: The basic game loop and Adding the DirectX Tool Kit which we will use for this lesson.

Background

In order to do a draw operation with Direct3D 12, we need to provide the following objects and settings:

• A vertex buffer containing the vertices of the elements to draw.
• A root signature which defines how the CPU and GPU shader programs share data.
• A pipeline state object which defines all state, the vertex input layout, and the compiled shader programs.
• A primitive topology setting that indicates how to interpret the individual vertices (as a point, a line, a triangle, etc.)

For this lesson, the BasicEffect object will provide the root signature and pipeline state object, VertexPositionColor will provide the input layout, and PrimitiveBatch will provide the vertex buffer and primitive topology.

Drawing a triangle

In the Game.h file, add the following variables to the bottom of the Game class's private declarations (right after the m_graphicsMemory variable you already added as part of setup):

using VertexType = DirectX::VertexPositionColor;

std::unique_ptr<DirectX::BasicEffect> m_effect;
std::unique_ptr<DirectX::PrimitiveBatch<VertexType>> m_batch;

In Game.cpp, add to the TODO of CreateDevice after where you have created m_graphicsMemory:

m_batch = std::make_unique<PrimitiveBatch<VertexType>>(m_d3dDevice.Get());

RenderTargetState rtState(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_D32_FLOAT);

EffectPipelineStateDescription pd(
    &VertexType::InputLayout,
    CommonStates::Opaque,
    CommonStates::DepthDefault,
    CommonStates::CullNone,
    rtState);

m_effect = std::make_unique<BasicEffect>(m_d3dDevice.Get(), EffectFlags::VertexColor, pd);

In Game.cpp, add to the TODO of OnDeviceLost:

m_effect.reset();
m_batch.reset();

In Game.cpp, add to the TODO of Render:

m_effect->Apply(m_commandList.Get());

m_batch->Begin(m_commandList.Get());

VertexPositionColor v1(Vector3(0.f, 0.5f, 0.5f), Colors::Yellow);
VertexPositionColor v2(Vector3(0.5f, -0.5f, 0.5f), Colors::Yellow);
VertexPositionColor v3(Vector3(-0.5f, -0.5f, 0.5f), Colors::Yellow);

m_batch->DrawTriangle(v1, v2, v3);

m_batch->End();

Build and run to see a simple yellow triangle rendered in 2D.

You don't have to use a type alias here like VertexType and you can just use DirectX::VertexPositionColor for the header and VertexPositionColor in the cpp file directly. I use the alias to simplify the tutorial a bit later on.

Pixel vs. normalized coordinates

The image above is drawn using coordinates that are independent of the screen resolution and range from -1 to +1. Resizing the window will result in the same image scaled to the new window. If instead you want to draw using screen pixel coordinates (which match the coordinate system used by SpriteBatch), then:

In Game.cpp, add to the TODO of CreateResources:

Matrix proj = Matrix::CreateScale( 2.f/float(backBufferWidth),
   -2.f/float(backBufferHeight), 1.f)
   * Matrix::CreateTranslation( -1.f, 1.f, 0.f );
m_effect->SetProjection(proj);

The projection matrix can also be created with Matrix::CreateOrthographicOffCenter(0.f, float(backBufferWidth), float(backBufferHeight), 0.f, 0.f, 1.f);

In Game.cpp, modify the TODO of Render:

m_effect->Apply(m_commandList.Get());

m_batch->Begin(m_commandList.Get());

VertexPositionColor v1(Vector3(400.f, 150.f, 0.f), Colors::Yellow);
VertexPositionColor v2(Vector3(600.f, 450.f, 0.f), Colors::Yellow);
VertexPositionColor v3(Vector3(200.f, 450.f, 0.f), Colors::Yellow);

m_batch->DrawTriangle(v1, v2, v3);

m_batch->End();

Build and run to get the same image, but if you resize the window the triangle will not change in the second version if your window size is 800 by 600.

Technical notes

• The BasicEffect family of shader classes uses shader code built in to the DirectXTK.lib as static data so there's no need to compile shaders at runtime or to load data files from disk.
• Internally, both SpriteBatch and PrimitiveBatch make use of a dynamic rather than static vertex buffer object.
• In Direct3D 12, all shader and state choices must be made when the pipeline state object is created. If you want to use different states or a different render target format you need to create a new IEffect instance.
• Since we haven't used any textures yet, we don't need a descriptor heap

State Objects

The use of CullNone for our rasterizer state above allows triangles and quads--which in Direct3D are just two triangles--to be drawn with arbitrary winding order. If you modify CreateDevice above as follows:

EffectPipelineStateDescription pd(
    &VertexType::InputLayout,
    CommonStates::Opaque,
    CommonStates::DepthDefault,
    CommonStates::CullClockwise,
    rtState);

Then build & run you run you will see nothing drawn because the triangle winding order was specified in clockwise order. If you changed it again to:

EffectPipelineStateDescription pd(
    &VertexType::InputLayout,
    CommonStates::Opaque,
    CommonStates::DepthDefault,
    CommonStates::CullCounterClockwise,
    rtState);

Then build & run you will see the triangle reappear.

For 'closed' objects, you typically use backface culling to speed up rendering which can quickly reject triangles that are not facing the viewer and avoids the need to run the pixel shader for those pixels.

The culling mode does not affect points or lines.

More to explore

• PrimitiveBatch is ideally suited for drawing debug displays such as visualizing bounding volumes, collision data, etc. For more on this, see DebugDraw.

Drawing with textures

Start by saving rocks.jpg into your new project's directory, and then from the top menu select Project / Add Existing Item.... Select "rocks.jpg" and click "OK".

In the Game.h file, add the following variable to the bottom of the Game class's private declarations (right after the m_graphicsMemory variable you already added as part of setup):

std::unique_ptr<DirectX::DescriptorHeap> m_resourceDescriptors;
Microsoft::WRL::ComPtr<ID3D12Resource> m_texture;

enum Descriptors
{
    Rocks,
    Count
};

In Game.cpp, add to the TODO of CreateDevice after where you have created m_graphicsMemory:

m_resourceDescriptors = std::make_unique<DescriptorHeap>(m_d3dDevice.Get(),
    D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
    D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
    Descriptors::Count);

ResourceUploadBatch resourceUpload(m_d3dDevice.Get());

resourceUpload.Begin();

DX::ThrowIfFailed(
    CreateWICTextureFromFile(m_d3dDevice.Get(), resourceUpload, L"rocks.jpg",
    m_texture.ReleaseAndGetAddressOf()));

CreateShaderResourceView(m_d3dDevice.Get(), m_texture.Get(),
    m_resourceDescriptors->GetCpuHandle(Descriptors::Rocks));

auto uploadResourcesFinished = resourceUpload.End(m_commandQueue.Get());

uploadResourcesFinished.wait();

In Game.cpp, add to the TODO of OnDeviceLost:

m_texture.Reset();
m_resourceDescriptors.reset();

UNDER CONSTRUCTION

Drawing with lighting

UNDER CONSTRUCTION

Next lesson: Line drawing and anti-aliasing

Further reading

DirectX Tool Kit docs CommonStates, Effects, EffectPipelineStateDescription, PrimitiveBatch, RenderTargetState, VertexTypes