more navigation buttons

Implementation.md

@@ -1,3 +1,6 @@
+|[[DirectXTK]]|
+|---|
+
 Be sure to read the [Implementation](https://github.com/Microsoft/DirectXTK/wiki/Implementation) page for _DirectX Tool Kit for DirectX 11_ as those topics also apply to _DirectX Tool Kit for DirectX 12_:
 
 * Complier conformance
@@ -34,6 +37,8 @@ Direct3D 12 headers have adopted strongly typed enum bitmask flags. If you need
 
 > Direct3D 11 headers do *not* make use of the strongly type enum bitmask flags. For this reason, if you need a parameter such as ``D3D11_BIND_FLAG`` the proper type is ``unsigned int``.
 
+See [this blog post](https://walbourn.github.io/modern-c++-bitmask-types/).
+
 # SAL annotation
 The _DirectX Toolkit_ library makes extensive use of SAL2 annotations (``_In_``, ``_Outptr_opt_``, etc.) which greatly improves the accuracy of the Visual C++ static code analysis (also known as PREFAST). The standard Windows headers ``#define`` them all to empty strings if not building with ``/analyze``, so they have no effect on code-generation.
 

Memory-Management.md

@@ -1,3 +1,6 @@
+|[[DirectXTK]]|
+|---|
+
 In DirectX 12, the application is responsible for much of the graphics memory management much as it is for system memory. This includes managing CPU/GPU synchronization and ensuring that resources are not modified by the CPU while the GPU is using them or vice-versa.
 
 For the _DirectX Tool Kit for DirectX 12_ this is primarily handled through two classes: [[GraphicsMemory]] and [[ResourceUploadBatch]].

Multi-GPU.md

@@ -1,3 +1,6 @@
+|[[DirectXTK]]|
+|---|
+
 DirectX 12 requires the application explicitly support multi-GPU scenarios through multiple devices.
 
 To support multi-GPUs, you need to create more than one Direct3D 12 device and create a [[GraphicsMemory]] instance for each one.
@@ -12,4 +15,4 @@ When creating resources or _DirectX Tool Kit_ rendering objects, you need to cre
 
 [Multi-Adapter Support in DirectX* 12](https://software.intel.com/en-us/articles/multi-adapter-support-in-directx-12) (Intel)
 
-[GDC 2016: Explicit Multi GPU Programming with DirectX 12](http://twvideo01.ubm-us.net/o1/vault/gdc2016/Presentations/Juha_Sjoholm_DX12_Explicit_Multi_GPU.pdf) (PDF, nVidia)
+[GDC 2016: Explicit Multi GPU Programming with DirectX 12](http://twvideo01.ubm-us.net/o1/vault/gdc2016/Presentations/Juha_Sjoholm_DX12_Explicit_Multi_GPU.pdf) (PDF, nVidia)

PSOs,-Shaders,-and-Signatures.md

@@ -1,3 +1,6 @@
+|[[DirectXTK]]|
+|---|
+
 In order to render using DirectX 12, the complete description of the render state needs to be captured in a ``ID3D12PipelineState`` interface object (PSO). Compiled shaders for all stages you use are bound to the PSO at creation time along with the vertex buffer input layout. In order to share data between the HLSL shader and the CPU, the ``ID3D12RootSignature`` interface object describes how the shader expects parameters to be bound and is also part of the PSO.
 
 # Creating root signatures

Resource-Barriers.md

@@ -1,3 +1,6 @@
+|[[DirectXTK]]|
+|---|
+
 When you are rendering or running a compute shader, many threads of work are executed on the GPU which in most cases is massively parallel hardware. In order to ensure all pending work (like rendering to a texture) is completed before you use the results in another operation, you have two choices:
 
 1. You can insert a fence, submit the command-list, and wait for the GPU to stall
@@ -135,4 +138,4 @@ The **Present** method will inject a resource barrier for the current back-buffe
 
 [A Look Inside D3D12 Resource State Barriers](https://devblogs.microsoft.com/directx/a-look-inside-d3d12-resource-state-barriers/)
 
-[DirectX 12: Resource Barriers and State Tracking (You-Tube)](https://www.youtube.com/watch?v=nmB2XMasz2o)
+[DirectX 12: Resource Barriers and State Tracking (You-Tube)](https://www.youtube.com/watch?v=nmB2XMasz2o)

Shader-Model-6.md

@@ -1,6 +1,9 @@
+|[[DirectXTK]]|
+|---|
+
 **As of the June 2021 release, *DirectX Tool Kit for DX12* defaults to using Shader Model 6 for VS 2019 projects. As of the October 2021 release, the VS 2017 projects use Shader Model 6. The [directx-vs-templates](https://github.com/walbourn/directx-vs-templates/releases) for DirectX 12 check for Shader Model 6 support as of May 2021.**
 
-Shader Model 6 is the latest HLSL compiler technology. It is required for DirectX Raytracing, DirectML, DirectX Mesh 
+Shader Model 6 is the latest HLSL compiler technology. It is required for DirectX Raytracing, DirectML, DirectX Mesh
  & Amplification Shaders, and a number of other DirectX 12 features. The DXIL compiler (``DXC`` ) generates Shader Model 6 programs, and the compiler is based on LLVM and is hosted on [GitHub](https://github.com/Microsoft/DirectXShaderCompiler).  A prebuilt version of ``DXC.EXE`` is provided in the Windows 10 SDK (17134 or later).
 
 > DirectX 11 does not support Shader Model 6 shaders.
@@ -71,7 +74,7 @@ If you wish to modify the Visual Studio ``vcxproj`` that invokes the shader buil
 <Target Name="ATGEnsureShaders" BeforeTargets="PrepareForBuild">
     <Exec Condition="!Exists('src/Shaders/Compiled/SpriteEffect_SpriteVertexShader.inc')"
           WorkingDirectory="$(ProjectDir)src/Shaders"
-          Command="CompileShaders dxil" 
+          Command="CompileShaders dxil"
           EnvironmentVariables="WindowsSdkVerBinPath=$(WDKBinRoot)" />
 </Target>
 ```

Textures.md

@@ -1,3 +1,6 @@
+|[[DirectXTK]]|
+|---|
+
 DirectX 12 textures are typically loaded into video memory which is not necessarily accessible to the CPU. For _DirectX Tool Kit for DirectX 12_, this is typically done by using the ``ID3D12Resource`` interface and the [[ResourceUploadBatch]] helper is used to transfer the texture data from the CPU to the GPU.
 
 # Creating textures