Update links

Chuck Walbourn 2019-03-26 01:21:55 -07:00
Родитель b1328777fd
Коммит e4beaaec87
31 изменённых файлов: 99 добавлений и 99 удалений

@ -229,5 +229,5 @@ case WM_DEVICECHANGE:
DirectX Tool Kit docs [[Audio]], [[AudioEngine]]
[DirectX Tool Kit for Audio](http://blogs.msdn.com/b/chuckw/archive/2013/12/25/directx-tool-kit-for-audio.aspx)
[Learning XAudio2](http://blogs.msdn.com/b/chuckw/archive/2012/05/15/learning-xaudio2.aspx)
[DirectX Tool Kit for Audio](https://walbourn.github.io/directx-tool-kit-for-audio/)
[Learning XAudio2](https://walbourn.github.io/learning-xaudio2/)

@ -7,7 +7,7 @@ First create a new project using the instructions from the first two lessons: [[
# NuGet package manager
If you used NuGet when [[Adding the DirectX Tool Kit]], then you already have support for _DirectX Tool Kit for Audio._. The id ``directxtk_desktop_2013`` and ``directxtk_desktop_2015`` packages are configured for Windows 7 and Windows Vista support, so it is making use of **XAudio 2.7**.
XAudio 2.7 requires the legacy DirectX SDK (June 2010). Due to some technical issues, it must be installed to the 'default' location of ``C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)``. To install the legacy DirectX SDK on your development system, see [this post](http://blogs.msdn.com/b/chuckw/archive/2010/06/15/10023137.aspx) and be sure to read [this article](http://blogs.msdn.com/b/chuckw/archive/2013/09/24/10246203.aspx) for a known issue with the installer.
XAudio 2.7 requires the legacy DirectX SDK (June 2010). Due to some technical issues, it must be installed to the 'default' location of ``C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)``. To install the legacy DirectX SDK on your development system, see [this post](https://walbourn.github.io/announcement-directx-sdk-june-2010-is-live/) and be sure to read [this article](https://walbourn.github.io/known-issue-directx-sdk-june-2010-setup-and-the-s1023-error/) for a known issue with the installer.
> The other platform NuGet packages do not require the legacy DirectX SDK as they always make use of XAudio 2.8 or later which is built into Windows 8.1 (``directxtk_windowsstore_8_1``), Windows 10 (``directxtk_uwp``, ``directxtk12_*``), Windows phone 8.1 (``directxtk_windowsphone_8_1``), and Xbox One.
@ -17,7 +17,7 @@ Complete the steps in **Adding the headers** below including the additional conf
If you used project-to-project references when [[Adding the DirectX Tool Kit]], then you need to add an additional _DirectX Tool Kit for Audio_ project to your solution. There are two choices depending on your platform target.
## XAudio 2.7
XAudio 2.7 supports Windows Vista, Windows 7, or later. It is deployed by the legacy _DirectX End User Runtime_ package and requires the legacy DirectX SDK (June 2010) to develop with. Due to some technical issues, it must be installed to the 'default' location of ``C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)``. To install the legacy DirectX SDK on your development system, see [this post](http://blogs.msdn.com/b/chuckw/archive/2010/06/15/10023137.aspx) and be sure to read [this article](http://blogs.msdn.com/b/chuckw/archive/2013/09/24/10246203.aspx) for a known issue with the installer.
XAudio 2.7 supports Windows Vista, Windows 7, or later. It is deployed by the legacy _DirectX End User Runtime_ package and requires the legacy DirectX SDK (June 2010) to develop with. Due to some technical issues, it must be installed to the 'default' location of ``C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)``. To install the legacy DirectX SDK on your development system, see [this post](https://walbourn.github.io/announcement-directx-sdk-june-2010-is-live/) and be sure to read [this article](https://walbourn.github.io/known-issue-directx-sdk-june-2010-setup-and-the-s1023-error/) for a known issue with the installer.
1. Right-click on your solution in the Solution Explorer, and select **Add** / **Existing Project...**
1. Browse into the "DirectXTK\Audio" folder and select ``DirectXTKAudio_Desktop_2013_DXSDK.vcxproj`` or ``DirectXTKAudio_Desktop_2015_DXSDK.vcxproj``, click "Open"
@ -106,7 +106,7 @@ If you are using XAudio 2.8, then your application should be built to require Wi
> XAudio 2.9 requires Windows 10 and ``_WIN32_WINNT`` being set to ``0x0A00``
# Deployment
If you are using XAudio 2.7, then your application has a dependency on the _DirectX End-User Runtime_. See [Not So DirectSetup](http://blogs.msdn.com/b/chuckw/archive/2010/09/08/not-so-direct-setup.aspx) for information on using this package.
If you are using XAudio 2.7, then your application has a dependency on the _DirectX End-User Runtime_. See [Not So DirectSetup](https://aka.ms/dxsetup) for information on using this package.
If you are using XAudio 2.8, then your application has a dependency on Windows 8.0 or later. If using XAudio 2.9, your application will only run on Windows 10 devices.
@ -114,5 +114,5 @@ If you are using XAudio 2.8, then your application has a dependency on Windows 8
# Further reading
DirectX Tool Kit docs [[Audio]]
[DirectX Tool Kit for Audio](http://blogs.msdn.com/b/chuckw/archive/2013/12/25/directx-tool-kit-for-audio.aspx)
[XAudio2 and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/04/02/xaudio2-and-windows-8-consumer-preview.aspx)
[DirectX Tool Kit for Audio](https://walbourn.github.io/directx-tool-kit-for-audio/)
[XAudio2 and Windows 8](https://walbourn.github.io/xaudio2-and-windows-8/)

@ -17,7 +17,7 @@ You can check for updates to the NuGet package by selecting "Updates/All" in the
> Both **directxtk_desktop_2015** and **directxtk_uwp** support VS 2017 as well.
# Project-to-project references
Another option rather than using NuGet is to use Visual Studio's [project-to-project references](http://blogs.msdn.com/b/vcblog/archive/2010/05/03/flexible-project-to-project-references.aspx). This approach is a little more setup, but it does ensure that you are building the full DirectX Tool Kit library as part of your solution, and allows you to make changes directly to the tool kit if desired as well.
Another option rather than using NuGet is to use Visual Studio's [project-to-project references](https://devblogs.microsoft.com/cppblog/flexible-project-to-project-references/). This approach is a little more setup, but it does ensure that you are building the full DirectX Tool Kit library as part of your solution, and allows you to make changes directly to the tool kit if desired as well.
* Extract the [release .zip file](https://github.com/Microsoft/DirectXTK/releases) into a directory relative to the new project you created. For this tutorial, we will assume the ``DirectXTK`` folder is in the same folder as your new project's Visual Studio Solution (``.sln``) file.
* Right-click on your solution in the Solution Explorer, and select **Add** / **Existing Project...**

@ -190,9 +190,9 @@ DirectXTK makes use of the latest Direct3D 11.1 headers available in the Windows
#pragma warning( disable : 4005 )
#include <C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)\Include\x3daudio.h>
> The NuGet package [directxtk_desktop_2015](https://www.nuget.org/packages/directxtk_desktop_2015/) is designed for Windows 7 compatibility for the main library, but any use of _DirectX Tool Kit for Audio_ uses XAudio 2.8. See [this blog post](https://blogs.msdn.microsoft.com/chuckw/2018/04/30/github-nuget-and-vso/) for details.
> The NuGet package [directxtk_desktop_2015](https://www.nuget.org/packages/directxtk_desktop_2015/) is designed for Windows 7 compatibility for the main library, but any use of _DirectX Tool Kit for Audio_ uses XAudio 2.8. See [this blog post](https://walbourn.github.io/github-nuget-and-vso/) for details.
> When using the legacy DirectX SDK you need to set up VC++ Directories paths in your project (particularly your EXE/DLL). For the Windows 8.1 SDK or Windows 10 SDK, you need to set up those paths in _reverse_ order from previous include orders. You really only need a small portion of the legacy DirectX SDK for XAudio 2.7, and want to be using the Windows 8.1 SDK / Windows 10 SDK for everything else. For more details see [The Zombie DirectX SDK](https://blogs.msdn.microsoft.com/chuckw/2015/03/23/the-zombie-directx-sdk/).
> When using the legacy DirectX SDK you need to set up VC++ Directories paths in your project (particularly your EXE/DLL). For the Windows 8.1 SDK or Windows 10 SDK, you need to set up those paths in _reverse_ order from previous include orders. You really only need a small portion of the legacy DirectX SDK for XAudio 2.7, and want to be using the Windows 8.1 SDK / Windows 10 SDK for everything else. For more details see [The Zombie DirectX SDK](https://aka.ms/AA4gfea).
# Content Pipeline
**Note:** When adding ``.xwb`` files to your Universal Windows Platform app or Xbox One XDK project, you need to manually set the file properties to "Content: Yes" for all configurations to have these files included in your AppX package. ``.wav`` files are automatically detected as a media file and are included as content by default.
@ -204,10 +204,10 @@ Note that ``IVoiceNotify::OnBufferEnd`` is called from XAudio2's thread, so the
# Further reading
[Learning XAudio2](http://blogs.msdn.com/b/chuckw/archive/2012/05/15/learning-xaudio2.aspx)
[Learning XAudio2](https://walbourn.github.io/learning-xaudio2/)
[XAudio2 and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/04/02/xaudio2-and-windows-8-consumer-preview.aspx)
[XAudio2 and Windows 8](https://walbourn.github.io/xaudio2-and-windows-8/)
[SoundLab](https://github.com/SimonDarksideJ/XNAGameStudio/wiki/SoundLab)
[The Zombie DirectX SDK](https://blogs.msdn.microsoft.com/chuckw/2015/03/23/the-zombie-directx-sdk/)
[The Zombie DirectX SDK](https://aka.ms/AA4gfea)

@ -165,7 +165,7 @@ The bulk of the Windows Runtime Template Library (WRL) is intended to make it ea
Because WRL is a pure C++ template library, it has no particular platform support requirements beyond being in the Windows 8.x or Windows 10 SDKs. You can therefore freely use it in Windows desktop applications built for Windows Vista, Windows 7, Windows 8.x, or Windows 10 as well as in Windows Store, Windows phone, Xbox One, and Universal Windows Platform apps.
> The Windows 8.0 SDK and later that includes WRL does not support targeting Windows XP / Windows Server 2003. For these older operating systems you have to make use of the Windows 7.1A SDK instead. See [this blog post](http://blogs.msdn.com/b/chuckw/archive/2012/11/26/visual-studio-2012-update-1.aspx) for more details.
> The Windows 8.0 SDK and later that includes WRL does not support targeting Windows XP / Windows Server 2003. For these older operating systems you have to make use of the Windows 7.1A SDK instead. See [this blog post](https://walbourn.github.io/visual-studio-2012-update-1/) for more details.
# Remark

@ -4,7 +4,7 @@ This is a simple light-weight DirectDraw Surface (``.dds``) file loader. This is
> To load FourCC "XBOX" variant ``.DDS`` files, use [[XboxDDSTextureLoader]], which is supported by the [xtexconv](https://aka.ms/atgsplxtexconv) utility.
This code is based on the legacy DirectX SDK sample [DDSWithoutD3DX](http://blogs.msdn.com/b/chuckw/archive/2010/07/15/ddswithoutd3dx-sample-update.aspx) texture loading code for Direct3D 9 / Direct3D 11. This version does not support Direct3D 9 or earlier.
This code is based on the legacy DirectX SDK sample [DDSWithoutD3DX](https://walbourn.github.io/ddswithoutd3dx-sample-update/) texture loading code for Direct3D 9 / Direct3D 11. This version does not support Direct3D 9 or earlier.
**Related tutorial:** [[Sprites and textures]]
@ -309,9 +309,9 @@ This function loads both traditional and FourCC "DX10" variant ``.DDS`` files.
[DDS on MSDN](https://docs.microsoft.com/en-us/windows/desktop/direct3ddds/dx-graphics-dds)
# Further Reading
[The DDS File Format Lives](http://blogs.msdn.com/b/chuckw/archive/2010/02/05/the-dds-file-format-lives.aspx)
[The DDS File Format Lives](https://walbourn.github.io/the-dds-file-format-lives/)
[Direct3D Feature Levels](http://blogs.msdn.com/b/chuckw/archive/2012/06/20/direct3d-feature-levels.aspx)
[Direct3D Feature Levels](https://aka.ms/Apsgrj)
[Programming Guide for DXGI](https://docs.microsoft.com/en-us/windows/desktop/direct3ddxgi/dx-graphics-dxgi-overviews)

@ -49,7 +49,7 @@ Press F5 to build and run the application It displays the following window:
> _Troubleshooting:_ If the base template fails to start, there are a few possibilities. First, if your system
> doesn't have any Direct3D capable device of any feature level, it will fail. This is pretty unlikely on modern
> versions of Windows. Second if it runs fine in _Release_ but fails in _Debug_, then you likely do not have the
> [proper DirectX Debug Device](http://blogs.msdn.com/b/chuckw/archive/2012/11/30/direct3d-sdk-debug-layer-tricks.aspx) installed for your operating system.
> [proper DirectX Debug Device](https://walbourn.github.io/direct3d-sdk-debug-layer-tricks/) installed for your operating system.
# Tour of the code
@ -287,7 +287,7 @@ The DeviceResources class methods are intended to be called from the main presen
# Platform notes
## Windows desktop apps
The **DeviceResources** implementation is designed to support Windows Vista SP2 and Windows 7 RTM with DirectX 11.0, but also supports Direct3D 11.1 on [Windows 7 SP 1](http://blogs.msdn.com/b/chuckw/archive/2012/11/14/directx-11-1-and-windows-7.aspx) or Windows 8 which provides [significant improvements](https://docs.microsoft.com/en-us/windows/desktop/direct3d11/direct3d-11-1-features) such as simplified interop with Direct2D/DirectWrite. Therefore, you should generally prefer to use **GetD3DDevice** / **GetD3DDeviceContext** / **GetSwapChain**, but where you explicitly need 11.1 features you call **GetD3DDevice1** / **GetD3DDeviceContext1** / **GetSwapChain1**. These will be nullptr if the system only has the DirectX 11.0 Runtime.
The **DeviceResources** implementation is designed to support Windows Vista SP2 and Windows 7 RTM with DirectX 11.0, but also supports Direct3D 11.1 on [Windows 7 SP 1](https://walbourn.github.io/directx-11-1-and-windows-7/) or Windows 8 which provides [significant improvements](https://docs.microsoft.com/en-us/windows/desktop/direct3d11/direct3d-11-1-features) such as simplified interop with Direct2D/DirectWrite. Therefore, you should generally prefer to use **GetD3DDevice** / **GetD3DDeviceContext** / **GetSwapChain**, but where you explicitly need 11.1 features you call **GetD3DDevice1** / **GetD3DDeviceContext1** / **GetSwapChain1**. These will be nullptr if the system only has the DirectX 11.0 Runtime.
## Universal Windows Platform apps
The UWP version of **DeviceResources** always uses [DirectX 11.3 interfaces](https://docs.microsoft.com/en-us/windows/desktop/direct3d11/direct3d-11-3-features).
@ -383,8 +383,8 @@ The ``backBufferFormat`` for PC/UWP should be ``DXGI_FORMAT_R10G10B10A2_UNORM``
See the tutorial [[Using HDR rendering]] for example usage.
# Further reading
[Direct3D Win32 Game Visual Studio template (Redux)](http://blogs.msdn.com/b/chuckw/archive/2015/12/17/direct3d-game-visual-studio-templates-redux.aspx)
[Anatomy of Direct3D 11 Create Device](http://blogs.msdn.com/b/chuckw/archive/2014/02/05/anatomy-of-direct3d-11-create-device.aspx)
[Direct3D Win32 Game Visual Studio template (Redux)](https://walbourn.github.io/direct3d-game-visual-studio-templates-redux/)
[Anatomy of Direct3D 11 Create Device](https://walbourn.github.io/anatomy-of-direct3d-11-create-device/)
[Visual Studio 2013 Windows Store DirectX Templates](http://blogs.msdn.com/b/ianhu/archive/2014/03/07/visual-studio-2013-windows-store-directx-templates.aspx)
[Linear-Space Lighting (i.e. Gamma)](http://filmicworlds.com/blog/linear-space-lighting-i-e-gamma/)

@ -65,8 +65,8 @@ SetDebugObjectName(ID3D11DeviceChild* resource, const char (&name)[TNameLength])
For more information on the Direct3D 11 debug layer, see these blog posts:
[Object Naming](http://blogs.msdn.com/b/chuckw/archive/2010/04/15/object-naming.aspx)
[Direct3D SDK Debug Layer Tricks](http://blogs.msdn.com/b/chuckw/archive/2012/11/30/direct3d-sdk-debug-layer-tricks.aspx)
[Object Naming](https://walbourn.github.io/object-naming/)
[Direct3D SDK Debug Layer Tricks](https://walbourn.github.io/direct3d-sdk-debug-layer-tricks/)
# Example

@ -48,7 +48,7 @@ using namespace DirectX;
# Building
This code is designed to build with Visual Studio 2015 or later. It requires the Windows 8.x / Windows 10 SDK for functionality such as the DirectXMath library and the DXGI 1.2 headers. Visual Studio 2015 or later already includes Windows 8.1 / Windows 10 SDK.
These components are designed to work without requiring any content from the DirectX SDK. For details, see [Where is the DirectX SDK?](https://docs.microsoft.com/en-us/windows/desktop/directx-sdk--august-2009-), [Where is the DirectX SDK (2013 Edition)?](http://blogs.msdn.com/b/chuckw/archive/2013/07/01/where-is-the-directx-sdk-2013-edition.aspx), [Where is the DirectX SDK (2015 Edition)?](https://blogs.msdn.microsoft.com/chuckw/2015/08/05/where-is-the-directx-sdk-2015-edition/), and [The Zombie DirectX SDK](https://blogs.msdn.microsoft.com/chuckw/2015/03/23/the-zombie-directx-sdk/).
These components are designed to work without requiring any content from the DirectX SDK. For details, see [Where is the DirectX SDK?](https://docs.microsoft.com/en-us/windows/desktop/directx-sdk--august-2009-), [Where is the DirectX SDK (2013 Edition)?](https://walbourn.github.io/where-is-the-directx-sdk-2013-edition/), [Where is the DirectX SDK (2015 Edition)?](https://aka.ms/dxsdk), and [The Zombie DirectX SDK](https://aka.ms/AA4gfea).
## HLSL shaders
The distribution package comes with a set of `Src\Shader\*.inc` files containing the compiled HLSL shaders which are included into the DirectXTK static library. They can be rebuilt if using a newer HLSL ``FXC.EXE`` or if the ``.fx`` or ``.hlsl`` files in the library are modified.
@ -95,7 +95,7 @@ In your application's solution, right-click on the Solution and use **Add \ Exis
</tr>
</table>
> For VS 2017, use of the [15.8 update](https://blogs.msdn.microsoft.com/chuckw/2018/08/16/vs-2017-15-8-update/) or [15.9 update](https://blogs.msdn.microsoft.com/chuckw/2018/11/15/vs-2017-15-9-update/) is recommended.
> For VS 2017, use of the [15.8 update](https://walbourn.github.io/vs-2017-15-8-update/) or [15.9 update](https://walbourn.github.io/vs-2017-15-9-update/) is recommended.
<table>
<tr>
@ -116,7 +116,7 @@ In your application's solution, right-click on the Solution and use **Add \ Exis
</tr>
</table>
> For VS 2015, use of the [Update 3](https://blogs.msdn.microsoft.com/chuckw/2016/06/27/visual-studio-2015-update-3/) is recommended.
> For VS 2015, use of the [Update 3](https://walbourn.github.io/visual-studio-2015-update-3/) is recommended.
In your application's project, right-click on the **Project** and use "References...", then "Add New Reference...", and then check the DirectXTK project name and click OK. For a Universal Windows Platform (UWP) app or Xbox One solution, you may need to set _Reference Assembly Output_ to false since DirectXTK is a static C++ library and not a WinRT component.
@ -128,7 +128,7 @@ In your application's project settings, on the "C++ / General" page set Configur
See [[Audio]] for additional information when setting up Windows desktop projects to use _DirectXTK for Audio_.
See also the [Visual C+ Team Blog](http://blogs.msdn.com/b/vcblog/archive/2010/05/03/flexible-project-to-project-references.aspx)
See also the [Visual C+ Team Blog](https://devblogs.microsoft.com/cppblog/flexible-project-to-project-references/)
## Using NuGet package manager
Alternatively you can use NuGet to install one of the DirectX Tool Kit packages. Use *Project / Manage NuGet Packages...* then select "Online" and search for "DirectXTK".
@ -148,7 +148,7 @@ DirectXTK makes use of C++ exception handling which should be enabled by the app
* [C++ Exception Handling](https://docs.microsoft.com/en-us/cpp/cpp/cpp-exception-handling)
* [How to: Break When an Exception is Thrown](https://docs.microsoft.com/en-us/visualstudio/debugger/managing-exceptions-with-the-debugger)
* [Dual-use Coding Techniques for Games](http://blogs.msdn.com/b/chuckw/archive/2012/09/17/dual-use-coding-techniques-for-games.aspx)
* [Dual-use Coding Techniques for Games](https://aka.ms/Fo3su4)
* [Resource Acquisition Is Initialization](http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization)
* [[ThrowIfFailed]]

@ -154,4 +154,4 @@ The built-in effects make use of the following states:
[New built-in effects in XNA Game Studio 4.0](http://www.shawnhargreaves.com/blog/new-built-in-effects-in-xna-game-studio-4-0.html)
[Built-in effects, permutations, and performance](http://www.shawnhargreaves.com/blog/built-in-effects-permutations-and-performance.html)
[HLSL, FXC, and D3DCompile](http://blogs.msdn.com/b/chuckw/archive/2012/05/07/hlsl-fxc-and-d3dcompile.aspx)
[HLSL, FXC, and D3DCompile](https://aka.ms/Tuoxjdx)

@ -152,5 +152,5 @@ if (state.IsConnected())
# Further reading
DirectX Tool Kit docs [[GamePad]]
[DirectX Tool Kit: Now with GamePads](http://blogs.msdn.com/b/chuckw/archive/2014/09/05/directx-tool-kit-now-with-gamepads.aspx)
[XInput and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/04/26/xinput-and-windows-8-consumer-preview.aspx)
[DirectX Tool Kit: Now with GamePads](https://walbourn.github.io/directx-tool-kit-now-with-gamepads/)
[XInput and Windows 8](https://walbourn.github.io/xinput-and-windows-8/)

@ -265,8 +265,8 @@ navigation.BackRequested([](const winrt::Windows::Foundation::IInspectable&, con
```
# Further reading
[DirectX Tool Kit: Now with GamePads](http://blogs.msdn.com/b/chuckw/archive/2014/09/05/directx-tool-kit-now-with-gamepads.aspx)
[XInput and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/04/26/xinput-and-windows-8-consumer-preview.aspx)
[XInput and XAudio2](http://blogs.msdn.com/b/chuckw/archive/2012/05/03/xinput-and-xaudio2.aspx)
[DirectX Tool Kit: Now with GamePads](https://walbourn.github.io/directx-tool-kit-now-with-gamepads/)
[XInput and Windows 8](https://walbourn.github.io/xinput-and-windows-8/)
[XInput and XAudio2](https://walbourn.github.io/xinput-and-xaudio2/)
[Xbox 360 Controller Images](https://github.com/SimonDarksideJ/XNAGameStudio/wiki/Xbox-360-Controller-Images)
[Xbox 360 Controller Buttons](https://github.com/SimonDarksideJ/XNAGameStudio/wiki/Xbox-360-Controller-Button-Images)

@ -12,8 +12,8 @@ This tutorial assumes the reader is familiar with the basics of C++ programming
This tutorial does not assume prior experience with Direct3D, but the reader should be familiar with the basic graphics concepts for DirectX or OpenGL. That said, you can get a long way using _DirectX Tool Kit_ without much in the way of graphics experience.
* [Getting Started with Direct3D 11](http://blogs.msdn.com/b/chuckw/archive/2011/07/11/getting-started-with-direct3d-11.aspx)
* [Book Recommendations](http://blogs.msdn.com/b/chuckw/archive/2014/04/07/book-recommendations.aspx)
* [Getting Started with Direct3D 11](https://walbourn.github.io/getting-started-with-direct3d-11/)
* [Book Recommendations](https://walbourn.github.io/book-recommendations/)
> Note that Direct3D 11 and _DirectX Tool Kit_ are not Windows Runtime (aka "WinRT") components, so we do not make use of the C++/CX language extensions or the ``/ZW`` switch. _DirectX Tool Kit_ is a 'pure' C++ library, which is why it's not directly usable by Visual Basic, C# or HTML+JavaScript applications.
@ -29,7 +29,7 @@ For debugging exceptions thrown by the _DirectX Tool Kit_, you should enable the
![Exception Settings](https://github.com/Microsoft/DirectXTK/wiki/images/DebugExcept.PNG)
> For some more detail on how the Visual Studio debugger deals with exceptions, read [this](https://blogs.msdn.microsoft.com/visualstudioalm/2015/01/07/understanding-exceptions-while-debugging-with-visual-studio/) blog post.
> For some more detail on how the Visual Studio debugger deals with exceptions, read [this](https://devblogs.microsoft.com/devops/understanding-exceptions-while-debugging-with-visual-studio/) blog post.
> In Visual Studio 2015/2017, the exception debugging options changed compared to VS 2013; see [this](https://blogs.msdn.microsoft.com/visualstudioalm/2015/02/23/the-new-exception-settings-window-in-visual-studio-2015/) blog post.
@ -39,18 +39,18 @@ These tutorials are written with game development in mind as the target applicat
# Software Setup
For learning purposes, these instructions are going to focus on the following setup:
* Visual Studio 2015 [Update 3](https://blogs.msdn.microsoft.com/chuckw/2016/06/27/visual-studio-2015-update-3/) or Visual Studio 2017 ([15.7 update](https://blogs.msdn.microsoft.com/chuckw/2018/05/07/vs-2017-15-7-update/) or [15.8 update](https://blogs.msdn.microsoft.com/chuckw/2018/08/16/vs-2017-15-8-update/)) Community, Professional, Premium, or Ultimate
* Visual Studio 2015 [Update 3](https://walbourn.github.io/visual-studio-2015-update-3/) or Visual Studio 2017 ([15.7 update](https://walbourn.github.io/vs-2017-15-7-update/) or [15.8 update](https://walbourn.github.io/vs-2017-15-8-update/)) Community, Professional, Premium, or Ultimate
* Windows 7 Service Pack 1, Windows 8.1, or Windows 10
We will be using a Win32 desktop application project template in order to support developers using Windows 7, but all these techniques and APIs apply to Universal Windows Platform apps and Xbox One as well.
> There is no need to install the legacy DirectX SDK to use DirectX Tool Kit. The DirectX SDK is deprecated and you should not use it. The only time you would need to install the legacy DirectX SDK for this tutorial series is if you are using Windows 7 for the audio portions. See [Microsoft Docs](https://docs.microsoft.com/en-us/windows/desktop/directx-sdk--august-2009-), [DirectX SDK Samples Catalog](http://blogs.msdn.com/b/chuckw/archive/2013/09/20/directx-sdk-samples-catalog.aspx), and [DirectX SDK Tools Catalog](http://blogs.msdn.com/b/chuckw/archive/2014/10/28/directx-sdk-tools-catalog.aspx).
> There is no need to install the legacy DirectX SDK to use DirectX Tool Kit. The DirectX SDK is deprecated and you should not use it. The only time you would need to install the legacy DirectX SDK for this tutorial series is if you are using Windows 7 for the audio portions. See [Microsoft Docs](https://docs.microsoft.com/en-us/windows/desktop/directx-sdk--august-2009-), [DirectX SDK Samples Catalog](https://walbourn.github.io/directx-sdk-samples-catalog/), and [DirectX SDK Tools Catalog](https://walbourn.github.io/directx-sdk-tools-catalog/).
## Visual Studio 2015
Be sure to install Visual C++ which requires using the _Custom_ install as it's not part of the _Typical_ install. See the [Visual C++ Team Blog](http://blogs.msdn.com/b/vcblog/archive/2015/07/24/setup-changes-in-visual-studio-2015-affecting-c-developers.aspx) for details.
Be sure to install Visual C++ which requires using the _Custom_ install as it's not part of the _Typical_ install. See the [Visual C++ Team Blog](https://devblogs.microsoft.com/cppblog/setup-changes-in-visual-studio-2015-affecting-c-developers/) for details.
## Visual Studio 2017
When using the [new lightweight installer](https://blogs.msdn.microsoft.com/vcblog/2016/08/22/the-lightweight-visual-studio-15-installer/) be sure to select the appropriate workloads. Here are the recommended options to select:
When using the [new lightweight installer](https://devblogs.microsoft.com/cppblog/the-lightweight-visual-studio-15-installer/) be sure to select the appropriate workloads. Here are the recommended options to select:
* Workload: _Game development with C++_
* Workload: _Desktop development with C++_
@ -112,5 +112,5 @@ For a quick introduction to DirectX 11 programming, take a look at the [Introduc
# Resources
[Dual-use Coding Techniques for Games](http://blogs.msdn.com/b/chuckw/archive/2012/09/17/dual-use-coding-techniques-for-games.aspx)
[Dual-use Coding Techniques for Games](https://aka.ms/Fo3su4)
[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md)

@ -2,7 +2,7 @@ http://go.microsoft.com/fwlink/?LinkId=248929
![DirectX Logo](https://github.com/Microsoft/DirectXTK/wiki/X_jpg.jpg)The **DirectX Tool Kit** (aka **DirectXTK**) is a collection of helper classes for writing **DirectX 11.x** code in C++.
See this [blog post](http://blogs.msdn.com/b/chuckw/archive/2012/03/02/directxtk.aspx).
See this [blog post](https://walbourn.github.io/directxtk/).
[[Getting Started]]
@ -31,7 +31,7 @@ DirectXTK is also available on NuGet
* [Windows phone 8.1](https://www.nuget.org/packages/directxtk_windowsphone_8_1)
# Porting from D3DX
See [this post](http://blogs.msdn.com/b/chuckw/archive/2013/08/21/living-without-d3dx.aspx) for a complete listing of D3DX equivalents.
See [this post](https://aka.ms/Kfsdiu) for a complete listing of D3DX equivalents.
# Credits

@ -72,5 +72,5 @@ SpriteBatch& operator= (SpriteBatch const&) = delete;
The library uses the [DirectXMath](https://docs.microsoft.com/en-us/windows/desktop/dxmath/pg-xnamath-internals#Call_Conventions) calling convention types to improve parameter passing of ``XMVECTOR`` and ``XMMATRIX`` types.
# Further Reading
[Dual-use Coding Techniques for Games](http://blogs.msdn.com/b/chuckw/archive/2012/09/17/dual-use-coding-techniques-for-games.aspx)
[Dual-use Coding Techniques for Games](https://aka.ms/Fo3su4)
[C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)

@ -129,5 +129,5 @@ The Keyboard class makes use of virtual keys and not scancodes so your code has
[QWERTY](https://en.wikipedia.org/wiki/QWERTY), [QWERTZ](https://en.wikipedia.org/wiki/QWERTZ), [AZERTY](https://en.wikipedia.org/wiki/AZERTY), [QZERTY](https://en.wikipedia.org/wiki/Keyboard_layout#QZERTY)
# Further reading
[DirectX Tool Kit: Keyboard and Mouse support](http://blogs.msdn.com/b/chuckw/archive/2015/08/06/directx-tool-kit-keyboard-and-mouse-support.aspx)
[DirectX Tool Kit: Keyboard and Mouse support](https://walbourn.github.io/directx-tool-kit-keyboard-and-mouse-support/)
[Using Keyboard Input](https://docs.microsoft.com/en-us/windows/desktop/inputdev/using-keyboard-input)

@ -90,9 +90,9 @@ for ( size_t h = 0; h < height; ++h )
# Further reading
[Introducing DirectXMath](http://blogs.msdn.com/b/chuckw/archive/2012/03/27/introducing-directxmath.aspx)
[DirectXMath 3.06](http://blogs.msdn.com/b/chuckw/archive/2013/10/24/directxmath-3-06.aspx)
[Known Issues: DirectXMath 3.06](http://blogs.msdn.com/b/chuckw/archive/2014/12/12/known-issues-directxmath-3-06.aspx)
[Spherical Harmonics Math](http://blogs.msdn.com/b/chuckw/archive/2012/07/28/spherical-harmonics-math.aspx)
[XDSP.H: Digital Signal Processing helper functions](http://blogs.msdn.com/b/chuckw/archive/2012/05/01/xdsp-h.aspx)
[DirectXMath instruction extensions series](http://blogs.msdn.com/b/chuckw/archive/2012/09/11/directxmath-sse-sse2-and-arm-neon.aspx)
[Introducing DirectXMath](https://walbourn.github.io/introducing-directxmath/)
[DirectXMath 3.06](https://walbourn.github.io/directxmath-3-06/)
[Known Issues: DirectXMath 3.06](https://walbourn.github.io/known-issues-directxmath-3-06/)
[Spherical Harmonics Math](https://walbourn.github.io/spherical-harmonics-math/)
[XDSP.H: Digital Signal Processing helper functions](https://walbourn.github.io/xdsp-h-digital-signal-processing-helper-functions/)
[DirectXMath instruction extensions series](https://walbourn.github.io/directxmath-sse-sse2-and-arm-neon/)

@ -139,7 +139,7 @@ Keep in mind that there are maximum primitive count limits per ModelMeshPart bas
See [[EffectFactory]] for more Feature Level notes.
[Direct3D feature levels](http://blogs.msdn.com/b/chuckw/archive/2012/06/20/direct3d-feature-levels.aspx)
[Direct3D feature levels](https://aka.ms/Apsgrj)
# Content Notes

@ -277,4 +277,4 @@ Build and run. Now in addition to keyboard controls, you can press & hold the le
# Further reading
DirectX Tool Kit docs [[Keyboard]], [[Mouse]]
[DirectX Tool Kit: Keyboard and Mouse support](http://blogs.msdn.com/b/chuckw/archive/2015/08/06/directx-tool-kit-keyboard-and-mouse-support.aspx)
[DirectX Tool Kit: Keyboard and Mouse support](https://walbourn.github.io/directx-tool-kit-keyboard-and-mouse-support/)

@ -176,5 +176,5 @@ For Universal Windows Platform apps, touch/pointer devices are captured as [mous
For Windows desktop apps, relative mouse movement is captured using "raw input" per the article [Taking Advantage of High-Definition Mouse Movement](https://docs.microsoft.com/en-us/windows/desktop/DxTechArts/taking-advantage-of-high-dpi-mouse-movement). Note that a consequence of this implementation is that relative mouse movement is not available when using the application through Remote Desktop.
# Further reading
[DirectX Tool Kit: Keyboard and Mouse support](http://blogs.msdn.com/b/chuckw/archive/2015/08/06/directx-tool-kit-keyboard-and-mouse-support.aspx)
[DirectX Tool Kit: Keyboard and Mouse support](https://walbourn.github.io/directx-tool-kit-keyboard-and-mouse-support/)
[Mouse Input](https://docs.microsoft.com/en-us/windows/desktop/inputdev/mouse-input)

@ -106,7 +106,7 @@ In order to support [all feature levels](https://docs.microsoft.com/en-us/window
Keep in mind there is a feature-level based limit on the maximum number of primitives in a single draw call, so the overall batch size needs to be under this limit. To support all feature levels, this should be 65535 or less lines or triangles in a single 'draw batch'.
[Direct3D Feature Levels](http://blogs.msdn.com/b/chuckw/archive/2012/06/20/direct3d-feature-levels.aspx)
[Direct3D Feature Levels](https://aka.ms/Apsgrj)
# Threading model

@ -22,56 +22,56 @@
[SpriteBatch and BasicEffect for C++ Direct3D 11](http://www.shawnhargreaves.com/blog/spritebatch-and-basiceffect-for-c-direct3d-11.html)
# DirectX SDK and Games for Windows Blog
[Direct3D Game Visual Studio templates (Redux)](https://blogs.msdn.microsoft.com/chuckw/2015/12/17/direct3d-game-visual-studio-templates-redux/)
[Direct3D Game Visual Studio templates (Redux)](https://walbourn.github.io/direct3d-game-visual-studio-templates-redux/)
[DirectX Tool Kit: Keyboard and Mouse support](https://blogs.msdn.microsoft.com/chuckw/2015/08/06/directx-tool-kit-keyboard-and-mouse-support/)
[DirectX Tool Kit: Keyboard and Mouse support](https://walbourn.github.io/directx-tool-kit-keyboard-and-mouse-support/)
[Where is the DirectX SDK (2015 Edition)?](https://blogs.msdn.microsoft.com/chuckw/2015/08/05/where-is-the-directx-sdk-2015-edition/)
[Where is the DirectX SDK (2015 Edition)?](https://aka.ms/dxsdk)
[Samples Content Exporter](http://blogs.msdn.com/b/chuckw/archive/2015/05/06/samples-content-exporter.aspx)
[Samples Content Exporter](https://walbourn.github.io/samples-content-exporter/)
[GitHub](http://blogs.msdn.com/b/chuckw/archive/2015/04/18/github.aspx)
[GitHub](https://walbourn.github.io/github/)
[The Zombie DirectX SDK](https://blogs.msdn.microsoft.com/chuckw/2015/03/23/the-zombie-directx-sdk/)
[The Zombie DirectX SDK](https://aka.ms/AA4gfea)
[Direct3D Win32 Game Visual Studio template](http://blogs.msdn.com/b/chuckw/archive/2015/01/06/direct3d-win32-game-visual-studio-template.aspx)
[Direct3D Win32 Game Visual Studio template](https://walbourn.github.io/direct3d-win32-game-visual-studio-template/)
[DirectX Tool Kit: Now with GamePads](http://blogs.msdn.com/b/chuckw/archive/2014/09/05/directx-tool-kit-now-with-gamepads.aspx)
[DirectX Tool Kit: Now with GamePads](https://walbourn.github.io/directx-tool-kit-now-with-gamepads/)
[CodePlex July 2014 Refresh](http://blogs.msdn.com/b/chuckw/archive/2014/07/31/codeplex-july-2014-refresh.aspx)
[CodePlex July 2014 Refresh](https://walbourn.github.io/codeplex-july-2014-refresh/)
[DirectX Tool Kit for Audio](http://blogs.msdn.com/b/chuckw/archive/2013/12/25/directx-tool-kit-for-audio.aspx)
[DirectX Tool Kit for Audio](https://walbourn.github.io/directx-tool-kit-for-audio/)
[CodePlex VS 2013 Refresh](http://blogs.msdn.com/b/chuckw/archive/2013/10/29/codeplex-vs-2013-refresh.aspx)
[CodePlex VS 2013 Refresh](https://walbourn.github.io/codeplex-vs-2013-refresh/)
[Visual Studio 2013 and Windows 8.1 SDK RTM are now available](http://blogs.msdn.com/b/chuckw/archive/2013/10/18/visual-studio-2013-and-windows-8-1-sdk-rtm-are-now-available.aspx)
[Visual Studio 2013 and Windows 8.1 SDK RTM are now available](https://walbourn.github.io/visual-studio-2013-and-windows-8-1-sdk-rtm-are-now-available/)
[Where is the DirectX SDK (2013 Edition)?](http://blogs.msdn.com/b/chuckw/archive/2013/07/01/where-is-the-directx-sdk-2013-edition.aspx)
[Where is the DirectX SDK (2013 Edition)?](https://walbourn.github.io/where-is-the-directx-sdk-2013-edition/)
[DirectX 11.1 and Windows 7 Update](http://blogs.msdn.com/b/chuckw/archive/2013/02/26/directx-11-1-and-windows-7-update.aspx)
[DirectX 11.1 and Windows 7 Update](https://walbourn.github.io/directx-11-1-and-windows-7-update/)
[DirectXTK Update](http://blogs.msdn.com/b/chuckw/archive/2013/01/27/directxtk-update.aspx)
[DirectXTK Update](https://walbourn.github.io/directxtk-update/)
[Direct3D SDK Debug Layer Tricks](http://blogs.msdn.com/b/chuckw/archive/2012/11/30/direct3d-sdk-debug-layer-tricks.aspx)
[Direct3D SDK Debug Layer Tricks](https://walbourn.github.io/direct3d-sdk-debug-layer-tricks/)
[Windows Imaging Component and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/11/19/windows-imaging-component-and-windows-8.aspx)
[Windows Imaging Component and Windows 8](https://walbourn.github.io/windows-imaging-component-and-windows-8/)
[DirectX 11.1 and Windows 7](http://blogs.msdn.com/b/chuckw/archive/2012/11/14/directx-11-1-and-windows-7.aspx)
[DirectX 11.1 and Windows 7](https://walbourn.github.io/directx-11-1-and-windows-7/)
[Dual-use Coding Techniques for Games](http://blogs.msdn.com/b/chuckw/archive/2012/09/17/dual-use-coding-techniques-for-games.aspx)
[Dual-use Coding Techniques for Games](https://aka.ms/Fo3su4)
[Visual Studio 2012 and Windows 8.0 SDK RTM are now available](http://blogs.msdn.com/b/chuckw/archive/2012/08/15/visual-studio-2012-and-windows-8-0-sdk-rtm-are-now-available.aspx)
[Visual Studio 2012 and Windows 8.0 SDK RTM are now available](https://walbourn.github.io/visual-studio-2012-and-windows-8-0-sdk-rtm-are-now-available/)
[Direct3D Feature Levels](http://blogs.msdn.com/b/chuckw/archive/2012/06/20/direct3d-feature-levels.aspx)
[Direct3D Feature Levels](https://aka.ms/Apsgrj)
[HLSL, FXC, and D3DCompile](http://blogs.msdn.com/b/chuckw/archive/2012/05/07/hlsl-fxc-and-d3dcompile.aspx)
[HLSL, FXC, and D3DCompile](https://aka.ms/Tuoxjdx)
[DirectXTK](http://blogs.msdn.com/b/chuckw/archive/2012/03/02/directxtk.aspx)
[DirectXTK](https://walbourn.github.io/directxtk/)
[DirectXTex](http://blogs.msdn.com/b/chuckw/archive/2011/10/28/directxtex.aspx)
[DirectXTex](https://walbourn.github.io/directxtex/)
[Where is the DirectX SDK?](http://blogs.msdn.com/b/chuckw/archive/2012/03/22/where-is-the-directx-sdk.aspx)
[Where is the DirectX SDK?](https://walbourn.github.io/where-is-the-directx-sdk/)
[Direct3D 11 Textures and Block Compression](http://blogs.msdn.com/b/chuckw/archive/2012/05/04/direct3d-11-textures-and-block-compression.aspx)
[Direct3D 11 Textures and Block Compression](https://walbourn.github.io/direct3d-11-textures-and-block-compression/)
[The DDS File Format Lives](http://blogs.msdn.com/b/chuckw/archive/2010/02/05/the-dds-file-format-lives.aspx)
[The DDS File Format Lives](https://walbourn.github.io/the-dds-file-format-lives/)

@ -132,7 +132,7 @@ WIC2 is available on Windows 10, Windows 8.x, and on Windows 7 Service Pack 1 wi
* If WIC2 is supported, then this function can make use of the new WIC pixel format ``GUID_WICPixelFormat96bppRGBFloat``.
See [Windows Imaging Component and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/11/19/windows-imaging-component-and-windows-8.aspx)
See [Windows Imaging Component and Windows 8](https://walbourn.github.io/windows-imaging-component-and-windows-8/)
# Windows Store apps
For _Save*TextureToFile_ to succeed, the application must have write access to the destination path. For Windows Store apps and Universal Windows Platform (UWP) app, the file access permissions are rather restricted so you'll need to make sure you use a fully qualified path to a valid write folder. A good location to use is the app data folder:

@ -1,4 +1,4 @@
``SimpleMath.h`` wraps the [DirectXMath](http://blogs.msdn.com/b/chuckw/archive/2012/03/27/introducing-directxmath.aspx) SIMD vector/matrix math API with an easier to use C++ interface. It provides the following types, with similar names, methods, and operator overloads to the XNA Game Studio math API:
``SimpleMath.h`` wraps the [DirectXMath](https://walbourn.github.io/introducing-directxmath/) SIMD vector/matrix math API with an easier to use C++ interface. It provides the following types, with similar names, methods, and operator overloads to the XNA Game Studio math API:
* [[Vector2]]
* [[Vector3]]

@ -175,7 +175,7 @@ Build and run we are rendering our 'clean' cat with premultiplied alpha:
* The switch ``-pmalpha`` causes the **texconv** command-line tool to convert the image to premultiplied alpha before saving the ``.dds`` file. This assumes the source image is in straight-alpha.
* The switch ``-m 1`` disables the generation of _mipmaps_ for the image. By default, the tool generates a full set of mipmaps when converting to a ``.dds``, but since our source image is not a power of two in width & height, it also generates a warning message about use with feature level 9.x devices. For standard sprites, we typically do not make use of _mipmaps_.
* The switch ``-f BC3_UNORM`` selects the ``DXGI_FORMAT_BC3_UNORM`` format for the resulting ``.dds`` file. In combination with the ``-pmalpha`` switch, this results in the "DXT4" [block-compression format](http://blogs.msdn.com/b/chuckw/archive/2012/05/04/direct3d-11-textures-and-block-compression.aspx) being used.
* The switch ``-f BC3_UNORM`` selects the ``DXGI_FORMAT_BC3_UNORM`` format for the resulting ``.dds`` file. In combination with the ``-pmalpha`` switch, this results in the "DXT4" [block-compression format](https://walbourn.github.io/direct3d-11-textures-and-block-compression/) being used.
# Rotating a sprite
@ -344,7 +344,7 @@ Build and run to see our cat drawing over a sunset background.
DirectX Tool Kit docs [[CommonStates]], [[DDSTextureLoader]], [[SpriteBatch]], [[WICTextureLoader]]
[Direc3D 11 Textures and Block Compression](http://blogs.msdn.com/b/chuckw/archive/2012/05/04/direct3d-11-textures-and-block-compression.aspx)
[Direc3D 11 Textures and Block Compression](https://walbourn.github.io/direct3d-11-textures-and-block-compression/)
[Premultiplied alpha](http://www.shawnhargreaves.com/blog/premultiplied-alpha.html)
[Premultiplied alpha and image composition](http://www.shawnhargreaves.com/blog/premultiplied-alpha-and-image-composition.html)

@ -85,4 +85,4 @@ Ticks are stored in unsigned 64-bit integers and second values are stored in ``d
# Further reading
[Understanding GameTime](http://www.shawnhargreaves.com/blog/understanding-gametime.html)
[Understanding Game Time Revisited](http://blogs.msdn.com/b/chuckw/archive/2014/12/03/understanding-game-time-revisited.aspx)
[Understanding Game Time Revisited](https://walbourn.github.io/understanding-game-time-revisited/)

@ -45,7 +45,7 @@ Press F5 to build and run the application It displays the following window:
> _Troubleshooting:_ If the base template fails to start, there are a few possibilities. First, if your system
> doesn't have any Direct3D capable device of any feature level, it will fail. This is pretty unlikely on modern
> versions of Windows. Second if it runs fine in _Release_ but fails in _Debug_, then you likely do not have the
> [proper DirectX Debug Device](http://blogs.msdn.com/b/chuckw/archive/2012/11/30/direct3d-sdk-debug-layer-tricks.aspx) installed for your operating system.
> [proper DirectX Debug Device](https://walbourn.github.io/direct3d-sdk-debug-layer-tricks/) installed for your operating system.
> **Xbox One**: the background color may be slightly oversaturated. This is because the basic Xbox One XDK template uses a backBufferFormat of ``DXGI_FORMAT_B8G8R8A8_UNORM_SRGB``. The DirectXMath Colors values are defined using standard [sRGB](https://en.wikipedia.org/wiki/SRGB) colorspace which is slightly different. All the colors defines need to be adjusted slightly for the linear RGB colorspace (aka gamma correct rendering) via ``XMColorSRGBToRGB``.
@ -77,7 +77,7 @@ void Game::Initialize(HWND window, int width, int height)
}
```
One of the two functions called by ``Initialize`` is the **CreateDevice** function which sets up a Direct3D 11.0 ([and optionally Direct3D 11.1](http://blogs.msdn.com/b/chuckw/archive/2014/02/05/anatomy-of-direct3d-11-create-device.aspx)) device using the maximum [Direct3D Feature Level](http://blogs.msdn.com/b/chuckw/archive/2012/06/20/direct3d-feature-levels.aspx) supported by the system which could range from 9.1 to 11.1. For _Debug_ builds, it enables the Direct3D "Debug device" which provides additional validation and diagnostic errors (seen in the "Output" window in Visual C++ when showing output from "Debug"). The TODO here is for adding the creation of objects that depend on the ``m_d3dDevice`` or ``m_d3dContext``, but do not care about the size of the rendering window.
One of the two functions called by ``Initialize`` is the **CreateDevice** function which sets up a Direct3D 11.0 ([and optionally Direct3D 11.1](https://walbourn.github.io/anatomy-of-direct3d-11-create-device/)) device using the maximum [Direct3D Feature Level](https://aka.ms/Apsgrj) supported by the system which could range from 9.1 to 11.1. For _Debug_ builds, it enables the Direct3D "Debug device" which provides additional validation and diagnostic errors (seen in the "Output" window in Visual C++ when showing output from "Debug"). The TODO here is for adding the creation of objects that depend on the ``m_d3dDevice`` or ``m_d3dContext``, but do not care about the size of the rendering window.
```cpp
// These are the resources that depend on the device.
@ -208,7 +208,7 @@ For these tutorials, we make use of the ``DXGI_FORMAT_B8G8R8A8_UNORM`` backbuffe
**Next lesson**: [[Adding the DirectX Tool Kit]]
# Further reading
[Direct3D Win32 Game Visual Studio template](http://blogs.msdn.com/b/chuckw/archive/2015/01/06/direct3d-win32-game-visual-studio-template.aspx)
[Direct3D Game Visual Studio templates (Redux)](https://blogs.msdn.microsoft.com/chuckw/2015/12/17/direct3d-game-visual-studio-templates-redux)
[Manifest Madness](http://blogs.msdn.com/b/chuckw/archive/2013/09/10/manifest-madness.aspx)
[Direct3D Win32 Game Visual Studio template](https://walbourn.github.io/direct3d-win32-game-visual-studio-template/)
[Direct3D Game Visual Studio templates (Redux)](https://walbourn.github.io/direct3d-game-visual-studio-templates-redux/)
[Manifest Madness](https://aka.ms/I6kdnw)
[64-bit programming for Game Developers](https://docs.microsoft.com/en-us/windows/desktop/DxTechArts/sixty-four-bit-programming-for-game-developers)

@ -43,7 +43,7 @@ if (FAILED(hr))
# Basic version
The ``ThrowIfFailed`` helper is not part of the _DirectX Tool Kit_; it's declared in some global header in your application. The C++ DirectX templates for Universal Windows Platform apps, Windows 8.x Store, Windows phone 8.x, Xbox One, and the [Direct3D Win32 Game](http://blogs.msdn.com/b/chuckw/archive/2015/01/06/direct3d-win32-game-visual-studio-template.aspx) templates all make use of the ``DX::ThrowIfFailed`` helper--you'll typically find it declared in the ``pch.h`` header.
The ``ThrowIfFailed`` helper is not part of the _DirectX Tool Kit_; it's declared in some global header in your application. The C++ DirectX templates for Universal Windows Platform apps, Windows 8.x Store, Windows phone 8.x, Xbox One, and the [Direct3D Win32 Game](https://walbourn.github.io/direct3d-win32-game-visual-studio-template/) templates all make use of the ``DX::ThrowIfFailed`` helper--you'll typically find it declared in the ``pch.h`` header.
```cpp
#include <exception>
@ -63,7 +63,7 @@ namespace DX
# Enhancements
The templates all include the basic implementation above, but production use might want to utilize a slightly improved version as follows (which are included in the [[DeviceResources]] variants of the [Direct3D Win32 Game](http://blogs.msdn.com/b/chuckw/archive/2015/12/17/direct3d-game-visual-studio-templates-redux.aspx) templates).
The templates all include the basic implementation above, but production use might want to utilize a slightly improved version as follows (which are included in the [[DeviceResources]] variants of the [Direct3D Win32 Game](https://walbourn.github.io/direct3d-game-visual-studio-templates-redux/) templates).
```cpp
#include <exception>

@ -162,7 +162,7 @@ WIC2 is available on Windows 10, Windows 8.x, and on Windows 7 Service Pack 1 wi
* If WIC2 is supported, then it will convert the WIC pixel format ``GUID_WICPixelFormat96bppRGBFixedPoint`` to ``DXGI_FORMAT_R32G32B32_FLOAT``. There is special-case handling so that if auto-gen mips fails for this format (this is optional support for Feature Level 10.0 or later devices), it will use ``DXGI_FORMAT_R32G32B32A32_FLOAT`` instead (which has required support for Feature Level 10.0 or later devices).
See [Windows Imaging Component and Windows 8](http://blogs.msdn.com/b/chuckw/archive/2012/11/19/windows-imaging-component-and-windows-8.aspx)
See [Windows Imaging Component and Windows 8](https://walbourn.github.io/windows-imaging-component-and-windows-8/)
# Windows Store apps
The texture loader function is typically used to load texture files from the application's install folder as they were included with the AppX package for Windows Store apps and Universal Windows Platform (UWP) apps. If you wish to create a texture from a file that is specified by the user from a WinRT file picker, you will need to copy the file locally to a temporary location before you can use WICTextureLoader on it. This is because you either won't have file access rights to the user's file location, or the StorageFile is actually not a local file system path (i.e. it's a URL).

@ -568,8 +568,8 @@ One final note, because we are using a render target that is larger than our blu
DirectX Tool Kit docs [[SpriteBatch]]
[HLSL, FXC, and D3DCompile](http://blogs.msdn.com/b/chuckw/archive/2012/05/07/hlsl-fxc-and-d3dcompile.aspx)
[What's up with D3DCompiler_xx.dll](http://blogs.msdn.com/b/chuckw/archive/2010/04/22/what-s-up-with-d3dcompiler-xx-dll.aspx)
[HLSL, FXC, and D3DCompile](https://aka.ms/Tuoxjdx)
[What's up with D3DCompiler_xx.dll](https://walbourn.github.io/whats-up-with-d3dcompiler_xx-dll)
[Compiling Shaders](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-part1)
[Gaussian blur](http://en.wikipedia.org/wiki/Gaussian_blur)

@ -60,7 +60,7 @@ The XACT3 GUI and/or the XACTBLD command-line tool in the legacy DirectX SDK (Di
**Endianness**: _DirectXTK for Audio_ does support loading Big-endian (aka Xbox 360) wave banks since those are the only kind that are generated when using the legacy tools with XMA compression when targeting the Xbox One XDK. This support is limited to XMA and 8-bit PCM data, however, as the wave data itself is not byte-swapped. XWBtool always builds Little-endian wave banks.
[Known Issue: DirectX SDK (June 2010) Setup and the S1023 Error](http://blogs.msdn.com/b/chuckw/archive/2011/12/09/known-issue-directx-sdk-june-2010-setup-and-the-s1023-error.aspx)
[Known Issue: DirectX SDK (June 2010) Setup and the S1023 Error](https://walbourn.github.io/known-issue-directx-sdk-june-2010-setup-and-the-s1023-error/)
[KB2728613](https://support.microsoft.com/en-us/kb/2728613)