ZFX + Developia

Code: Alles auswählen

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Test
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN		// -> Nur die nötigsten Komponten verwenden.
#define STRICT					// -> Keine eigenen typedefs() erlauben.
#define NOGDICAPMASKS			// -> CC_*, LC_*, PC_*, CP_*, TC_*, RC_
#define NOSYSMETRICS			// -> SM_*
#define NOMENUS					// -> MF_*
#define NOKEYSTATES				// -> MK_*
#define NORASTEROPS				// -> Binary und Tertiary raster ops.
#define NOATOM					// -> Atom Manager Routinen.
#define NOCLIPBOARD				// -> Clipboard Routinen.
#define NOCOLOR					// -> Screen colors.
#define NOCTLMGR				// -> Control und Dialog Routinen.
#define NODRAWTEXT				// -> DrawText() und DT_*
#define NOKERNEL				// -> Alle KERNEL defines und Routinen.
#define NOMEMMGR				// -> GMEM_*, LMEM_*, GHND, LHND, dazugehörige Routinen.
#define NOMETAFILE				// -> typedef METAFILEPICT
#define NOMINMAX				// -> Macros min(a,b) und max(a,b)
#define NOOPENFILE				// -> ::OpenFile(), ::OemToAnsi(), ::AnsiToOem(), und OF_*
#define NOSCROLL				// -> SB_* und scrolling Routinen.
#define NOSERVICE				// -> Alle Service Controller Routinen, SERVICE_ equates, etc.
#define NOSOUND					// -> Sound driver Routinen
#define NOTEXTMETRIC			// -> typedef TEXTMETRIC und dazugehörige Routinen.
#define NOWH					// -> ::SetWindowsHook() und WH_*
#define NOCOMM					// -> COMM driver Routinen.
#define NOKANJI					// -> Kanji support Komponenten.
#define NOHELP					// -> Help engine Schnittstelle.
#define NOPROFILER				// -> Profiler Schnittstelle.
#define NODEFERWINDOWPOS		// -> ::DeferWindowPos() Routinen.
#define NOMCX					// -> Modem Configuration Extensions.

// #define NOICONS				// -> IDI_*
// #define NOSYSCOMMANDS		// -> SC_*
// #define NOSHOWWINDOW			// -> SW_*
// #define NOGDI				// -> Alle GDI defines und Routinen -> ::GetStockObject()
// #define NOUSER				// -> Alle USER defines und Routinen -> ::CreateWindowExA/W()
// #define NONLS				// -> Alle NLS defines und Routinen -> ::WideCharToMultiByte()
// #define NOMB					// -> MB_* -> ::MessageBoxA/W()
// #define NOMSG				// -> typedef MSG und dazugehörige Routinen.
// #define NOWINOFFSETS			// -> GWL_*, GCL_*, und dazugehörige Routinen.
// #define NOVIRTUALKEYCODES	// -> VK_*
// #define NOWINMESSAGES		// -> WM_*, EM_*, LB_*, CB_*
// #define NOWINSTYLES			// -> WS_*, CS_*, ES_*, LBS_*, SBS_*, CBS_*

#include <Windows.h>
#include <DXGI.h>
#include <D3D11.h>
#include <DxErr.h>

#pragma comment(lib, "DXGI.lib")
#pragma comment(lib, "D3D11.lib")
#pragma comment(lib, "DxErr.lib")

#include <exception>
#include <string>
#include <sstream>
#include <memory>				// -> std::unique_ptr
#include <utility>				// -> std::pair
#include <cassert>

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Manifest.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#if defined _M_IX86
#pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#elif defined _M_IA64 
#pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#elif defined _M_X64 
#pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#else 
#pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") 
#endif

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// INonCopyAssignable.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	// Bewirkt, dass eine Instanz weder kopiert noch zugewiesen werden kann.
	class INonCopyAssignable
	{
	protected:

		INonCopyAssignable() {}

	private:

		INonCopyAssignable(INonCopyAssignable const &);
		INonCopyAssignable & operator = (INonCopyAssignable const &);
	};
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Exception.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	class Exception : public std::exception
	{
	public:

		explicit Exception(std::string const & message) : exception(message.c_str()) {}
	};

	void ThrowException(std::string const & message)
	{
		std::stringstream format;
		format << "Exception -> " << message;
		throw Exception(format.str());
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsException.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	class WindowsException : public Exception
	{
	public:

		explicit WindowsException(std::string const & message) : Exception(message) {}
	};

	void ThrowWindowsException(std::string const & message, ::DWORD error = ::GetLastError())
	{
		std::stringstream format;
		format << "Windows Exception [" << error << "] -> " << message; // TODO: WindowsErrorToStringA() ...
		throw WindowsException(format.str());
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DirectXException.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	class DirectXException : public Exception
	{
	public:

		explicit DirectXException(std::string const & message) : Exception(message) {}
	};

	void ThrowDirectXException(std::string const & message, ::HRESULT error)
	{
		std::stringstream format;
		format << "DirectX Exception [" << ::DXGetErrorStringA(error) << "] -> " << message;
		throw WindowsException(format.str());
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsUTF8Encode.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		// Nicht die schnellste Implementation, aber es funktioniert.
		std::string UTF8Encode(std::wstring const & original)
		{
			auto const newSize(::WideCharToMultiByte(
				CP_UTF8, 
				0,
				&original[0], 
				static_cast<int>(original.size()),
				nullptr, 
				0, 
				nullptr, 
				nullptr));
			
			std::string output(newSize, 0);		
			
			::WideCharToMultiByte(
				CP_UTF8, 
				0,
				&original[0], 
				static_cast<int>(original.size()), 
				&output[0], 
				newSize, 
				nullptr, 
				nullptr);
			
			return output; // Sollte zu keiner Kopie führen.
		}

		// Nicht die schnellste Implementation, aber es funktioniert.
		std::wstring UTF8Encode(std::string const & original)
		{
			auto const newSize(::MultiByteToWideChar(
				CP_UTF8, 
				0, 
				&original[0], 
				static_cast<int>(original.size()),
				nullptr, 
				0));
			
			std::wstring output(newSize, 0);
			
			::MultiByteToWideChar(
				CP_UTF8, 
				0, 
				&original[0], 
				static_cast<int>(original.size()), 
				&output[0], 
				newSize);
			
			return output; // Sollte zu keiner Kopie führen.
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsWindowClass.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		class WindowClass : protected INonCopyAssignable
		{
		public:

			explicit WindowClass(::WNDCLASSEXW const & description) : myDescription(description)
			{
				if (!::RegisterClassExW(&myDescription))
				{
					ThrowWindowsException("::RegisterClassExW() failed.");
				}
			}

			// Darf keine Ausnahme auslösen.
			~WindowClass()
			{
				::UnregisterClassW(myDescription.lpszClassName, myDescription.hInstance);
			}

		private:

			::WNDCLASSEXW const myDescription;
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsListener.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{		
		// Bewirkt, dass eine Instanz Fensternachrichten verarbeiten kann.
		class IListener
		{
		public:

			// Darf keine Ausnahme auslösen.
			virtual bool MessageHandler(::UINT /* message */, ::WPARAM /* firstParameter */, ::LPARAM /* secondParameter */)
			{
				return true;
			}

		protected:

			IListener() {}
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsInternal.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		namespace Internal
		{
			// Darf keine Ausnahme auslösen.
			::LRESULT CALLBACK MessageProcedure(::HWND window, ::UINT message, ::WPARAM firstParameter, ::LPARAM secondParameter)
			{
				// Die beim Erstellen des Fensters übergebene Instanz speichern damit dessen Nachrichtenhandler
				// aufgerufen werden kann.
				if (message == WM_NCCREATE)
				{
					::SetWindowLongPtrW(
						window,
						GWL_USERDATA,
						reinterpret_cast<::LONG_PTR>(
						reinterpret_cast<::LPCREATESTRUCTW>(secondParameter)->lpCreateParams));
				}

				auto const toListener(reinterpret_cast<IListener *>(::GetWindowLongPtrW(window, GWL_USERDATA)));

				// Dem Nachrichtenhandler vertrauen dass dieser keine Ausnahme auslöst.
				if (toListener && !toListener->MessageHandler(message, firstParameter, secondParameter))
				{
					return 0;
				}

				// Nicht weiterverarbeiten da ansonsten ::DestroyWindow() aufgerufen wird. Dies aber erledigt
				// der jeweilige Destruktor des Fensters selber.
				if (message == WM_CLOSE)
				{
					return 0;
				}

				return ::DefWindowProcW(window, message, firstParameter, secondParameter);
			}
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsWindow.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		class Window : protected INonCopyAssignable
		{
		public:

			Window(
				::DWORD style,
				::DWORD extendedStyle,
				::LPCWSTR toClassName,
				::LPCWSTR toWindowName,
				int positionX,
				int positionY,
				int width,
				int height,
				::HWND parentWindow,
				::HMENU menu,
				::HINSTANCE moduleInstance,
				IListener * toListener) :

				myWindow(::CreateWindowExW(
					extendedStyle,
					toClassName,
					toWindowName,
					style,
					positionX,
					positionY,
					width,
					height,
					parentWindow,
					menu,
					moduleInstance,
					reinterpret_cast<::LPVOID>(toListener)))
			{
				if (myWindow == nullptr)
				{
					ThrowWindowsException("::CreateWindowExW() failed.");
				}
			}

			// Darf keine Ausnahme auslösen.
			~Window()
			{
				::DestroyWindow(myWindow);
			}

			// Bewirkt, dass die Fensterklasse als ::HWND Argument übergeben werden kann.
			operator ::HWND const () const
			{
				return myWindow;
			}

			::HWND const GetHandle() const
			{
				return myWindow;
			}

		private:

			::HWND myWindow;
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsUtility.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		typedef std::pair<::UINT, ::UINT> SizeType;
		typedef std::pair<::DWORD, ::DWORD> StyleType;

		namespace Area
		{
			enum Type
			{
				Desktop,
				Workspace
			};
		}

		// Verwendet standardmässig die interne Nachrichtenprozedur.
		::WNDCLASSEXW CreateWindowClassDescription(
			::UINT size,
			::UINT style,
			int extraBytesForClass,
			int extraBytesForWindow,
			::HINSTANCE moduleInstance,
			::HICON icon,
			::HICON smallIcon,
			::HCURSOR cursor,
			::HBRUSH backgroundColor,
			::LPCWSTR toMenuName,
			::LPCWSTR toClassName)
		{
			::WNDCLASSEXW windowClass;
			windowClass.cbSize = size;
			windowClass.style = style;
			windowClass.lpfnWndProc = &Internal::MessageProcedure;
			windowClass.cbClsExtra = extraBytesForClass;
			windowClass.cbWndExtra = extraBytesForWindow;
			windowClass.hInstance = moduleInstance;
			windowClass.hIcon = icon;
			windowClass.hIconSm = smallIcon;
			windowClass.hCursor = cursor;
			windowClass.hbrBackground = backgroundColor;
			windowClass.lpszMenuName = toMenuName;
			windowClass.lpszClassName = toClassName;

			return windowClass; // Sollte zu keiner Kopie führen.
		}

		// Platziert das Fenster in der Mitte des nächstgelegenen Desktops oder Arbeitsbereiches.
		// Der Arbeitsbereich entspricht dem Desktop minus der Taskleiste.
		void CenterWindowAtNearestArea(::HWND const window, Area::Type area)
		{
			assert(window != nullptr);

			::RECT rectangle;
			::GetWindowRect(window, &rectangle);
            
			auto const width(rectangle.right - rectangle.left);
			auto const height(rectangle.bottom - rectangle.top);
			auto const monitor(::MonitorFromRect(&rectangle, MONITOR_DEFAULTTONEAREST));

			::MONITORINFO monitorInfo;
			monitorInfo.cbSize = sizeof(monitorInfo);			
			::GetMonitorInfoW(monitor, &monitorInfo);

			const auto right((area == Area::Desktop) ? 
				monitorInfo.rcMonitor.right : 
				monitorInfo.rcWork.right);
			
			const auto bottom((area == Area::Desktop) ? 
				monitorInfo.rcMonitor.bottom : 
				monitorInfo.rcWork.bottom);

			::SetWindowPos(
				window,
				nullptr, 
				static_cast<int>((right - width) * 0.5),
				static_cast<int>((bottom - height) * 0.5),
				0,
				0, 
				SWP_NOSIZE |
				SWP_NOZORDER |
				SWP_NOACTIVATE);
		}

		SizeType GetWindowClientSize(::HWND const window)
		{
			assert(window != nullptr);

			::RECT rectangle = { 0 };
			::GetClientRect(window, &rectangle);
						
			// Sollte zu keiner Kopie führen.
			return SizeType(
				static_cast<::UINT>(rectangle.right), 
				static_cast<::UINT>(rectangle.bottom));
		}

		void SetWindowClientSize(::HWND const window, ::UINT width, ::UINT height)
		{
			assert(window != nullptr);

			::RECT rectangle = { 0 };
			rectangle.right = static_cast<::LONG>(width);
			rectangle.bottom = static_cast<::LONG>(height);
			
			::AdjustWindowRectEx(
				&rectangle,
				static_cast<::DWORD>(::GetWindowLongPtrW(window, GWL_STYLE)), 
				FALSE, 
				static_cast<::DWORD>(::GetWindowLongPtrW(window, GWL_EXSTYLE)));
		
			::SetWindowPos(
				window,
				nullptr, 
				0, 
				0, 
				static_cast<int>(rectangle.right - rectangle.left), 
				static_cast<int>(rectangle.bottom - rectangle.top), 
				SWP_NOMOVE | 
				SWP_NOZORDER |
				SWP_NOACTIVATE);
		}

		StyleType GetWindowStyle(::HWND const window)
		{
			assert(window != nullptr);

			// Sollte zu keiner Kopie führen.
			return StyleType(
				static_cast<::DWORD>(::GetWindowLongPtrW(window, GWL_STYLE)),
				static_cast<::DWORD>(::GetWindowLongPtrW(window, GWL_EXSTYLE)));
		}

		void SetWindowStyle(::HWND const window, ::DWORD style, ::DWORD extendedStyle)
		{
			assert(window != nullptr);

			::SetWindowLongPtrW(window, GWL_STYLE, static_cast<::LONG_PTR>(style));
			::SetWindowLongPtrW(window, GWL_EXSTYLE, static_cast<::LONG_PTR>(extendedStyle));

			::SetWindowPos(
				window,
				HWND_TOP, 
				0, 
				0,
				0,
				0,
				SWP_NOMOVE |
				SWP_NOSIZE | 
				SWP_NOZORDER |
				SWP_SHOWWINDOW |
				SWP_FRAMECHANGED);
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsWindowPlacement.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		class WindowPlacement
		{
		public:

			WindowPlacement()
			{
				ZeroMemory(&myPlacement, sizeof(::WINDOWPLACEMENT));
				myPlacement.length = sizeof(::WINDOWPLACEMENT);
			}

			void Get(::HWND const window)
			{
				assert(window != nullptr);
				::GetWindowPlacement(window, &myPlacement);
			}

			void Set(::HWND const window)
			{
				assert(window != nullptr);
				::SetWindowPlacement(window, &myPlacement);
			}

		private:

			::WINDOWPLACEMENT myPlacement;
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsHiddenCursor.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		class HiddenCursor : protected INonCopyAssignable
		{
		public:

			HiddenCursor()
			{
				::ShowCursor(FALSE);
			}

			// Darf keine Ausnahme auslösen.
			~HiddenCursor()
			{
				::ShowCursor(TRUE);
			}
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsTimer.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		// Ein Hight-Resolution Timer.
		class Timer
		{
		public:

			Timer() : myRunningTime(0.0f), myElapsedTime(0.0f)
			{
				if (!::QueryPerformanceFrequency(&myFrequency))
				{
					ThrowException("::QueryPerformanceFrequency() failed.");
				}

				if (!::QueryPerformanceCounter(&myStartTime))
				{
					ThrowException("::QueryPerformanceCounter() failed.");
				}

				myPreviousTime = myStartTime;
			}

			float GetRunningTime() const
			{
				return myRunningTime;
			}

			float GetElapsedTime() const
			{
				return myElapsedTime;
			}

			void Update()
			{
				::LARGE_INTEGER currentTime;
				::QueryPerformanceCounter(&currentTime);

				myRunningTime = static_cast<float>(
					static_cast<double>(currentTime.QuadPart - myStartTime.QuadPart) / 
					static_cast<double>(myFrequency.QuadPart));
		
				myElapsedTime = static_cast<float>(
					static_cast<double>(currentTime.QuadPart - myPreviousTime.QuadPart) / 
					static_cast<double>(myFrequency.QuadPart));

				if (myPreviousTime.QuadPart < currentTime.QuadPart) // Sicherheitshalber.
				{
					myPreviousTime = currentTime;
				}

				if (myRunningTime < 0.0f) // Sicherheitshalber.
				{
					myRunningTime = 0.0f;
				}

				if (myElapsedTime < 0.0f) // Sicherheitshalber.
				{
					myElapsedTime = 0.0f;
				}
			}

		private:

			float myRunningTime;
			float myElapsedTime;

			::LARGE_INTEGER myFrequency;
			::LARGE_INTEGER myStartTime;
			::LARGE_INTEGER myPreviousTime;
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsKeyboardState.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows
	{
		// Speichert einen Tastaturstatus.
		class KeyboardState
		{
		public:

			KeyboardState()
			{
				ZeroMemory(&myBuffer, sizeof(bool) * 256);
			}
	
			bool & operator[](::DWORD virtualKey)
			{
				assert(virtualKey >= 0 && virtualKey < 255);
				return myBuffer[virtualKey];
			}
	
			bool const & operator[](::DWORD virtualKey) const
			{
				assert(virtualKey >= 0 && virtualKey < 255);
				return myBuffer[virtualKey];
			}

		private:

			bool myBuffer[256]; // Sollte ausreichen.
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindowsKeyboard.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace Windows	
	{
		class Keyboard
		{
		public:

			void Update()
			{
				myOldState = myNewState;
				myNewState = myCurrentState;
			}
	
			bool IsDown(::DWORD virtualKey) const
			{
				return myNewState[virtualKey];
			}
	
			bool IsToggled(::DWORD virtualKey) const
			{
				return myNewState[virtualKey] && !myOldState[virtualKey];
			}
	
			// Verarbeitet Tastaturnachrichten.
			// Darf keine Ausnahme auslösen.
			void MessageHandler(::UINT message, ::WPARAM firstParameter, ::LPARAM secondParameter)
			{
				switch (message)
				{
					case WM_KEYDOWN:
					case WM_SYSKEYDOWN:
					{
						myCurrentState[static_cast<::DWORD>(firstParameter & 0xFF)] = true;
						myCurrentState[VK_MENU] = (secondParameter & (1 << 29)) != 0;
						break;
					}
					case WM_KEYUP:
					case WM_SYSKEYUP:
					{
						myCurrentState[static_cast<::DWORD>(firstParameter & 0xFF)] = false;
						myCurrentState[VK_MENU] = (secondParameter & (1 << 29)) != 0;
						break;
					}
				}
			}

		private:

			KeyboardState myOldState;
			KeyboardState myNewState;
			KeyboardState myCurrentState;
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DirectXReference.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace DirectX
	{		
		void AddReference(::IUnknown * toReference)
		{
			if (toReference)
			{
				toReference->AddRef();
			}
		}

		// Darf keine Ausnahme auslösen -> Wird von einem Destruktor aufgerufen.
		void ReleaseReference(::IUnknown * toReference)
		{
			if (toReference)
			{
				toReference->Release();
			}
		}

		// Spezialisierung für ein Devicekontext damit alle ausstehenden Renderbefehle verworfen werden können.
		// Darf keine Ausnahme auslösen -> Wird von einem Destruktor aufgerufen.
		void ReleaseReference(::ID3D11DeviceContext * toContext)
		{
			if (toContext)
			{
				// Prüfen, ob es die letzte Referenz ist.				
				if (toContext->AddRef() == 2)
				{
					toContext->ClearState();
					toContext->Flush();
				}
				
				toContext->Release();				
				toContext->Release();
			}
		}

		// Spezialisierung für ein Swapchain da dieses nur im Fensterstatus freigegeben werden kann.
		// Darf keine Ausnahme auslösen -> Wird von einem Destruktor aufgerufen.
		void ReleaseReference(::IDXGISwapChain * toSwapChain)
		{
			if (toSwapChain)
			{
				// Prüfen, ob es die letzte Referenz ist.
				if (toSwapChain->AddRef() == 2)
				{					
					toSwapChain->SetFullscreenState(FALSE, nullptr);
				}
					
				toSwapChain->Release();
				toSwapChain->Release();
			}
		}	
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DirectXPointer.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace DirectX
	{
		template <typename InterfaceType>
		class Pointer
		{
		public:

			// Initialisiert die Schnittstelle mit nullptr.	
			Pointer() :	toMyInterface(nullptr) {}

			// Initialisiert die Schnittstelle.	
			explicit Pointer(InterfaceType * toInterface) : toMyInterface(toInterface) {}
		
			// Erstellt eine Kopie eines Zeigers.
			// Inkrementiert anschliessend den Referenzzähler der neuen Schnittstelle.	
			Pointer(Pointer const & pointer) : toMyInterface(pointer.toMyInterface)
			{
				AddReference(toMyInterface);
			}

			// Move-Konstruktor -> Initialisiert die Schnittstelle mit einem Zeiger.	
			Pointer(Pointer && pointer) : toMyPointer(std::move(pointer.toMyInterface))
			{			
				pointer.toMyInterface = nullptr;
			}

			// Dekrementiert den Referenzzähler der Schnittstelle.
			// Darf keine Ausnahme auslösen.	
			~Pointer()
			{
				ReleaseReference(toMyInterface);				
			}
		
			// Weist einen Zeiger zu.
			// Dekrementiert zuerst den Referenzzähler der bestehenden Schnittstelle.
			// Inkrementiert anschliessend den Referenzzähler der neuen Schnittstelle.	
			Pointer & operator = (Pointer const & pointer)
			{
				if (this != pointer) // Selbstzuweisung verhindern.
				{
					ReleaseReference(toMyInterface);
					toMyInterface = pointer.toMyInterface;
					AddReference(toMyInterface);
				}

				return *this;
			}

			// Move-Operator -> Weist einen Zeiger zu.
			// Dekrementiert zuerst den Referenzzähler der bestehenden Schnittstelle.	
			Pointer & operator = (Pointer && pointer)
			{
				if (this != pointer) // Selbstzuweisung verhindern.
				{
					ReleaseReference(toMyInterface);
					toMyInterface = std::move(pointer.toMyInterface);					
					pointer.toMyInterface = nullptr;
				}

				return *this;
			}
		
			// Gibt die Schnittstelle zurück damit diese als Argument verwendet werden kann.	
			operator InterfaceType * () const
			{
				return toMyInterface;
			}

			// Gibt die Adresse der Schnittstelle zurück damit diese initialisiert werden kann.	
			InterfaceType ** operator & ()
			{
				assert(toMyInterface == nullptr); // Muss uninitialisiert sein.
				return &toMyInterface;
			}
		
			// Dereferenziert den Zeiger.	
			InterfaceType & operator * () const
			{ 
				assert(toMyInterface != nullptr); // Muss initialisiert sein.
				return *toMyInterface;
			}

			// Erlaubt den Zugriff auf die Schnittstellenimplementation.	
			InterfaceType * operator -> () const
			{
				assert(toMyInterface != nullptr); // Muss initialisiert sein.
				return toMyInterface;
			}

			// Gibt die Schnittstelle zurück.	
			InterfaceType * Get() const
			{
				return toMyInterface;
			}

			// Weist eine neue Schnittstelle zu.
			// Dekrementiert zuerst den Referenzzähler der bestehenden Schnittstelle.	
			void Reset(InterfaceType * toInterface)
			{
				if (toMyInterface != toInterface) // Selbstzuweisung verhindern.
				{
					ReleaseReference(toMyInterface);
					toMyInterface = toInterface;
				}
			}

		private:

			InterfaceType * toMyInterface; // Kann auch uninitialisiert sein.
		};
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// D3D11.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace D3D11
	{
		// ::D3D11CreateDevice()
		::ID3D11Device * CreateDevice(
			::IDXGIAdapter * toAdapter, 
			::D3D_DRIVER_TYPE driverType, 
			::HMODULE software, 
			::UINT flags, 
			::D3D_FEATURE_LEVEL const * toFeatureLevels,
			::UINT featureLevelCount,
			::UINT sdkVersion,				
			::D3D_FEATURE_LEVEL * toFeatureLevel,
			::ID3D11DeviceContext ** toImmediateContext)			
		{
			::ID3D11Device * toDevice(nullptr);			
			auto const result(::D3D11CreateDevice(
				toAdapter,
				driverType,
				software,
				flags,
				toFeatureLevels,
				featureLevelCount,
				sdkVersion,
				&toDevice,
				toFeatureLevel,
				toImmediateContext));

			if (FAILED(result))
			{
				ThrowDirectXException("::D3D11CreateDevice() failed.", result);
			}

			return toDevice;
		}

		namespace Device
		{		
			// ID3D11Device::CheckMultisampleQualityLevels()
			::UINT CheckMultisampleQualityLevels(::ID3D11Device * toDevice, ::DXGI_FORMAT format, ::UINT sampleCount)
			{
				assert(toDevice != nullptr);

				::UINT qualityLevels(0);
				auto const result(toDevice->CheckMultisampleQualityLevels(format, sampleCount, &qualityLevels));

				if (FAILED(result))
				{
					ThrowDirectXException("ID3D11Device::CheckMultisampleQualityLevels() failed.", result);
				}

				return qualityLevels;
			}

			// ID3D11Device::CreateTexture2D()
			::ID3D11Texture2D * CreateTexture2D(
				::ID3D11Device * toDevice, 
				::D3D11_TEXTURE2D_DESC const * toDescription,
				::D3D11_SUBRESOURCE_DATA const * toInitialData)
			{
				assert(toDevice != nullptr);

				::ID3D11Texture2D * toTexture(nullptr);
				auto const result(toDevice->CreateTexture2D(toDescription, toInitialData, &toTexture));

				if (FAILED(result))
				{
					ThrowDirectXException("ID3D11Device::CreateTexture2D() failed.", result);
				}

				return toTexture;
			}

			// ID3D11Device::CreateRenderTargetView()
			::ID3D11RenderTargetView * CreateRenderTargetView(
				::ID3D11Device * toDevice, 
				::ID3D11Resource * toResource, 
				::D3D11_RENDER_TARGET_VIEW_DESC const * toDescription)
			{
				assert(toDevice != nullptr);

				::ID3D11RenderTargetView * toView(nullptr);
				auto const result(toDevice->CreateRenderTargetView(toResource, toDescription, &toView));

				if (FAILED(result))
				{
					ThrowDirectXException("ID3D11Device::CreateRenderTargetView() failed.", result);
				}

				return toView;
			}

			// ID3D11Device::CreateDepthStencilView()
			::ID3D11DepthStencilView * CreateDepthStencilView(
				::ID3D11Device * toDevice, 
				::ID3D11Resource * toResource, 
				::D3D11_DEPTH_STENCIL_VIEW_DESC const * toDescription)
			{
				assert(toDevice != nullptr);

				::ID3D11DepthStencilView * toView(nullptr);
				auto const result(toDevice->CreateDepthStencilView(toResource, toDescription, &toView));

				if (FAILED(result))
				{
					ThrowDirectXException("ID3D11Device::CreateDepthStencilView() failed.", result);
				}

				return toView;
			}
		}

		namespace Texture2D
		{
			// ID3D11Texture2D::GetDesc()
			::D3D11_TEXTURE2D_DESC GetDescription(::ID3D11Texture2D * toTexture)
			{
				assert(toTexture != nullptr);

				::D3D11_TEXTURE2D_DESC description;
				toTexture->GetDesc(&description);

				return description; // Sollte zu keiner Kopie führen.
			}
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DXGI.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	namespace DXGI
	{
		// ::CreateDXGIFactory1()
		::IDXGIFactory1 * CreateFactory1()
		{
			::IDXGIFactory1 * toFactory(nullptr);			
			auto const result(::CreateDXGIFactory1(
				__uuidof(::IDXGIFactory1), 
				reinterpret_cast<void **>(&toFactory)));

			if (FAILED(result))
			{
				ThrowDirectXException("::CreateDXGIFactory1() failed.", result);
			}

			return toFactory;
		}
		
		namespace Factory1
		{	
			// IDXGIFactory1::EnumAdapters1()
			::IDXGIAdapter1 * EnumerateAdapters(::IDXGIFactory1 * toFactory, ::UINT adapterOrdinal)
			{
				assert(toFactory != nullptr);

				::IDXGIAdapter1 * toAdapter(nullptr);
				auto const result(toFactory->EnumAdapters1(adapterOrdinal, &toAdapter));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGIFactory1::EnumAdapters1() failed.", result);
				}

				return toAdapter;
			}

			// IDXGIFactory1::CreateSwapChain()
			::IDXGISwapChain * CreateSwapChain(
				::IDXGIFactory1 * toFactory, 
				::IUnknown * toDevice, 
				::DXGI_SWAP_CHAIN_DESC /* const */ & description)
			{
				assert(toFactory != nullptr);
				assert(toDevice != nullptr);

				::IDXGISwapChain * toSwapChain(nullptr);
				auto const result(toFactory->CreateSwapChain(toDevice, &description, &toSwapChain));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGIFactory1::CreateSwapChain() failed.", result);
				}

				return toSwapChain;
			}
		
			// IDXGIFactory1::MakeWindowAssociation()
			void MakeWindowAssociation(::IDXGIFactory1 * toFactory, ::HWND const window, ::UINT flags)
			{
				assert(toFactory != nullptr);
				assert(window != nullptr);

				auto const result(toFactory->MakeWindowAssociation(window, flags));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGIFactory1::MakeWindowAssociation() failed.", result);
				}
			}	
		}

		namespace Adapter1
		{		
			// IDXGIAdapter1::GetDesc1()
			::DXGI_ADAPTER_DESC1 GetDescription(::IDXGIAdapter1 * toAdapter)
			{
				assert(toAdapter != nullptr);

				::DXGI_ADAPTER_DESC1 description;
				auto const result(toAdapter->GetDesc1(&description));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGIAdapter1::GetDesc1() failed.", result);
				}

				return description; // Sollte zu keiner Kopie führen.
			}

			// IDXGIAdapter1::EnumOutputs()
			::IDXGIOutput * EnumerateOutputs(::IDXGIAdapter1 * toAdapter, ::UINT outputOrdinal)
			{
				assert(toAdapter != nullptr);

				::IDXGIOutput * toOutput(nullptr);
				auto const result(toAdapter->EnumOutputs(outputOrdinal, &toOutput));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGIAdapter1::EnumOutputs() failed.", result);
				}

				return toOutput;
			}
		}

		namespace Output 
		{
			// IDXGIOutput::GetDesc()
			::DXGI_OUTPUT_DESC GetDescription(::IDXGIOutput * toOutput)
			{
				assert(toOutput != nullptr);

				::DXGI_OUTPUT_DESC description;
				auto const result(toOutput->GetDesc(&description));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGIOutput::GetDesc() failed.", result);
				}

				return description; // Sollte zu keiner Kopie führen.
			}
		}

		namespace SwapChain
		{
			// IDXGISwapChain::GetContainingOutput()
			::IDXGIOutput * GetContainingOutput(::IDXGISwapChain * toSwapChain)
			{
				assert(toSwapChain != nullptr);

				::IDXGIOutput * toOutput(nullptr);
				auto const result(toSwapChain->GetContainingOutput(&toOutput));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGISwapChain::GetContainingOutput() failed.", result);
				}

				return toOutput;
			}

			// IDXGISwapChain::GetBuffer()
			void * GetBuffer(::IDXGISwapChain * toSwapChain, ::UINT bufferID, ::IID interfaceID)
			{
				assert(toSwapChain != nullptr);

				void * toSurface(nullptr);
				auto const result(toSwapChain->GetBuffer(bufferID, interfaceID, &toSurface));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGISwapChain::GetBuffer() failed.", result);
				}

				return toSurface;
			}

			// IDXGISwapChain::ResizeBuffers()
			void ResizeBuffers(
				::IDXGISwapChain * toSwapChain,
				::UINT bufferCount,
				::UINT width,
				::UINT height,
				::DXGI_FORMAT format,
				::UINT swapChainFlags)
			{
				assert(toSwapChain != nullptr);
				auto const result(toSwapChain->ResizeBuffers(bufferCount, width, height, format, swapChainFlags));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGISwapChain::ResizeBuffers() failed.", result);
				}
			}

			// IDXGISwapChain::ResizeTarget()
			void ResizeTarget(::IDXGISwapChain * toSwapChain, ::DXGI_MODE_DESC const & description)
			{
				assert(toSwapChain != nullptr);
				auto const result(toSwapChain->ResizeTarget(&description));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGISwapChain::ResizeTarget() failed.", result);
				}
			}

			// IDXGISwapChain::GetFullscreenState()
			bool IsFullscreen(::IDXGISwapChain * toSwapChain)
			{
				assert(toSwapChain != nullptr);
				
				::BOOL fullscreen;
				toSwapChain->GetFullscreenState(&fullscreen, nullptr);

				return fullscreen == TRUE;
			}

			// IDXGISwapChain::GetDesc()
			::DXGI_SWAP_CHAIN_DESC GetDescription(::IDXGISwapChain * toSwapChain)
			{
				assert(toSwapChain != nullptr);

				::DXGI_SWAP_CHAIN_DESC description;
				auto const result(toSwapChain->GetDesc(&description));

				if (FAILED(result))
				{
					ThrowDirectXException("IDXGISwapChain::GetDesc() failed.", result);
				}

				return description; // Sollte zu keiner Kopie führen.
			}

			// IDXGISwapChain::SetFullscreenState()
			void SetFullscreenState(::IDXGISwapChain * toSwapChain, bool fullscreen, ::IDXGIOutput * toOutput)
			{
				assert(toSwapChain != nullptr);

				if (fullscreen)
				{
					auto const result(toSwapChain->SetFullscreenState(TRUE, toOutput));

					if (FAILED(result))
					{
						ThrowDirectXException("IDXGISwapChain::SetFullscreenState() failed.", result);
					}
				}
				else
				{
					toSwapChain->SetFullscreenState(FALSE, nullptr);
				}
			}

			// IDXGISwapChain::Present()
			bool Present(::IDXGISwapChain * toSwapChain, ::UINT interval, ::UINT flags)
			{
				assert(toSwapChain != nullptr);

				auto const result(toSwapChain->Present(interval, flags));

				switch (result)
				{
					case S_OK:
					{
						break;
					}
					case DXGI_STATUS_OCCLUDED:
					{
						return false;
					}
					default:
					{
						ThrowDirectXException("IDXGISwapChain::Present() failed.", result);						
						break; // Wird nie erreicht.
					}
				}

				return true;
			}
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Application.hpp/cpp
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
	class Application : protected Windows::IListener, protected INonCopyAssignable
	{
	public:

		explicit Application(::HINSTANCE const moduleInstance) :
			
			// Die Fensterklasse initialisieren.
			myWindowClass(Windows::CreateWindowClassDescription(
				sizeof(::WNDCLASSEXW),
				CS_DBLCLKS,				
				0,
				0,
				moduleInstance,
				::LoadIconW(nullptr, IDI_APPLICATION), // moduleInstance, MAKEINTRESOURCE(...))
				::LoadIconW(nullptr, IDI_APPLICATION), // moduleInstance, MAKEINTRESOURCE(...))
				::LoadCursorW(nullptr, IDC_ARROW),
				reinterpret_cast<::HBRUSH>(::GetStockObject(BLACK_BRUSH)),
				nullptr,
				L"TestWindow")),

			myValidState(true),
			myRunningState(true),
			myFocusState(false),
			myOccludedState(false),
			myLostFullscreenState(false),

			myTime(0.0f),
			myTick(1.0f / 60.0f), // -> 60 mal pro Sekunde ticken.
			myTickBuffer(0.0f)
		{
			InitializeRenderDevice();

			std::wstringstream windowText;
			windowText << L"Test - " << DXGI::Adapter1::GetDescription(myGraphicsAdapter).Description;

			// Das Fenster kann nicht in der Initialisierungsliste initialisiert werden da während dem Erstellen
			// verschiedene Nachrichten gesendet werden und zu diesem Zeitpunkt die Anwendungsinstanz noch nicht
			// fertig konstruiert ist.
			myWindow.reset(new Windows::Window(
				WS_OVERLAPPEDWINDOW,
				WS_EX_APPWINDOW,
				L"TestWindow",
				windowText.str().c_str(),
				CW_USEDEFAULT,
				CW_USEDEFAULT,
				CW_USEDEFAULT,
				CW_USEDEFAULT,
				nullptr,
				nullptr,
				moduleInstance,								
				this)); // -> Windows::IListener.

			Windows::SetWindowClientSize(*myWindow, 1280, 720);
			Windows::CenterWindowAtNearestArea(*myWindow, Windows::Area::Workspace);

			::ShowWindow(*myWindow, SW_SHOWNORMAL);
			::SetForegroundWindow(*myWindow);

			// Nicht minimiert starten.
			if (::IsIconic(*myWindow))
			{
				::ShowWindow(*myWindow, SW_RESTORE);
			}

			myClientSize = Windows::GetWindowClientSize(*myWindow);
						
			InitializeSwapChain();
			InitializeSwapChainDepencies();
		}

		bool IsRunning() const
		{
			return myValidState && myRunningState;
		}

		void Update()
		{
			if (!myValidState || !myRunningState)
			{
				return;
			}

			myTimer.Update();

			// Da nicht bei jedem Vollbildstatusverlust eine WA_ACTIVATE oder WA_ACTIVATEAPP Nachricht gesendet
			// wird, vor jedem Aktualisierungsvorgang einen Test durchführen.
			HandlePossibleLostFullscreenState();

			if (::IsIconic(*myWindow))
			{
				return;
			}

			myValidState = false;

			if (myLostFullscreenState)
			{
				myLostFullscreenState = false;
				ToggleScreen();
			}
			else if (HandlePossibleClientSizeChange())
			{
				ReleaseSwapChainDepencies();

				// Die neue Buffergrösse automatisch ermitteln.
				DXGI::SwapChain::ResizeBuffers(
					mySwapChain,
					0,
					0,
					0,
					::DXGI_FORMAT_UNKNOWN,
					::DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);

				InitializeSwapChainDepencies();
			}				
			
			// Alle Ressourcen sind korrekt initialisiert.
			myValidState = true;

			if (myOccludedState)
			{	
				// Prüfen, ob der Renderbereich wieder bereit ist.
				myOccludedState = DXGI::SwapChain::Present(mySwapChain, 0, DXGI_PRESENT_TEST);
			}
			else
			{
				if (myFocusState)
				{					
					myTickBuffer += myTimer.GetElapsedTime();

					// Die Anwendung unabhängig der Framerate ticken lassen.
					while (myTickBuffer >= myTick)
					{
						myTime += myTick;
						myTickBuffer -= myTick;
						Tick();
					}
				}

				Render();
			}
		}

	private:

		// Darf keine Ausnahme auslösen.
		bool MessageHandler(::UINT message, ::WPARAM firstParameter, ::LPARAM secondParameter)
		{
			switch (message)
			{
				case WM_ACTIVATE:
				case WM_ACTIVATEAPP:
				{
					myFocusState = firstParameter != WA_INACTIVE;

					// Prüfen, ob der Vollbildstatus verloren gegangen ist.
					if (myRunningState && mySwapChain.Get())
					{								
						HandlePossibleLostFullscreenState();
					}

					break;
				}
				case WM_GETMINMAXINFO:
				{
					// Die minimale Fenstergrösse (nicht Klientgrösse) festlegen.
					reinterpret_cast<::MINMAXINFO *>(secondParameter)->ptMinTrackSize.x = 400;
					reinterpret_cast<::MINMAXINFO *>(secondParameter)->ptMinTrackSize.y = 400;
					break;
				}
				case WM_KEYDOWN:
				case WM_SYSKEYDOWN:
				case WM_KEYUP:
				case WM_SYSKEYUP:
				{
					myKeyboard.MessageHandler(message, firstParameter, secondParameter);
					break;
				}
				case WM_CLOSE:
				case WM_DESTROY:
				{
					// WM_CLOSE wird nicht weiterverarbeitet.
					myRunningState = false;
					break;
				}
				case WM_SYSCOMMAND:
				{
					switch (firstParameter & 0xFFF0)
					{
						case SC_KEYMENU:
						{
							// Nicht verwendete Menüverknüpfungen deaktivieren.							
							return false;
						}
						case SC_MONITORPOWER:
						case SC_SCREENSAVE:
						{
							// Wenn das Fenster fokusiert ist, den Energiesparmodus und den Bildschirmschoner
							// daktivieren.							
							return !myFocusState;
						}
					}

					break;
				}
			}

			return true;
		}

		void InitializeRenderDevice()
		{
			// Den Standardadapter verwenden.
			myGraphicsFactory.Reset(DXGI::CreateFactory1());
			myGraphicsAdapter.Reset(DXGI::Factory1::EnumerateAdapters(myGraphicsFactory, 0));
					
			::D3D_FEATURE_LEVEL featureLevel(::D3D_FEATURE_LEVEL_9_1);
			::UINT createFlags(0);

#if defined(DEBUG) || defined(_DEBUG)
			createFlags |= ::D3D11_CREATE_DEVICE_DEBUG;
#endif
			// Ein Renderdevice anhand des ermittelten Adapters erstellen.
			myRenderDevice.Reset(D3D11::CreateDevice(
				myGraphicsAdapter,
				::D3D_DRIVER_TYPE_UNKNOWN,
				nullptr,
				createFlags,
				nullptr,
				0,
				D3D11_SDK_VERSION,
				&featureLevel,
				&myRenderContext));

			if (featureLevel < ::D3D_FEATURE_LEVEL_11_0)
			{
				// TODO: Kein Shadermodel 5.0.
			}
		}

		void InitializeSwapChain()
		{
			// Die Buffergrösse sowie die Bildwiederholfrequenz automatisch ermitteln.
			::DXGI_SWAP_CHAIN_DESC swapChain;
			swapChain.BufferDesc.Format = ::DXGI_FORMAT_R8G8B8A8_UNORM;
			swapChain.BufferDesc.Width = 0;
			swapChain.BufferDesc.Height = 0;
			swapChain.BufferDesc.RefreshRate.Numerator = 0;
			swapChain.BufferDesc.RefreshRate.Denominator = 0;
			swapChain.BufferDesc.ScanlineOrdering = ::DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
			swapChain.BufferDesc.Scaling = ::DXGI_MODE_SCALING_UNSPECIFIED;
			swapChain.BufferCount = 2;			
			swapChain.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
			swapChain.Flags = ::DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
			swapChain.OutputWindow = *myWindow;
			swapChain.SwapEffect = ::DXGI_SWAP_EFFECT_DISCARD;
			swapChain.Windowed = TRUE;
			swapChain.SampleDesc.Count = 4;
			
			// Nach der bestmöglichen Qualität suchen. Diese entspricht dem ermittelten Wert minus 1.

			auto const sampleQuality(D3D11::Device::CheckMultisampleQualityLevels(
				myRenderDevice, 
				swapChain.BufferDesc.Format,
				swapChain.SampleDesc.Count));
				
			assert(sampleQuality != 0); // Direct3D 11 muss 4 x MSAA unterstützen.
			swapChain.SampleDesc.Quality = sampleQuality - 1;
										
			mySwapChain.Reset(DXGI::Factory1::CreateSwapChain(myGraphicsFactory, myRenderDevice, swapChain));

			// Die Fensterverwaltung selber übernehmen.
			DXGI::Factory1::MakeWindowAssociation(
				myGraphicsFactory, 
				*myWindow, 
				DXGI_MWA_NO_WINDOW_CHANGES | 
				DXGI_MWA_NO_ALT_ENTER | 
				DXGI_MWA_NO_PRINT_SCREEN);
		}

		void InitializeSwapChainDepencies()
		{
			myBackBuffer.Reset(reinterpret_cast<::ID3D11Texture2D *>(
				DXGI::SwapChain::GetBuffer(mySwapChain, 0, __uuidof(::ID3D11Texture2D))));

			myBackBufferView.Reset(D3D11::Device::CreateRenderTargetView(myRenderDevice, myBackBuffer, nullptr));
			
			// Den Depthstencilbuffer dem Backbuffer anpassen.
			auto const backBuffer(D3D11::Texture2D::GetDescription(myBackBuffer));
						
			::D3D11_TEXTURE2D_DESC depthStencil;
			depthStencil.Width = backBuffer.Width;
			depthStencil.Height = backBuffer.Height;
			depthStencil.MipLevels = 1;
			depthStencil.ArraySize = 1;
			depthStencil.Format = ::DXGI_FORMAT_D24_UNORM_S8_UINT;
			depthStencil.SampleDesc = backBuffer.SampleDesc;
			depthStencil.Usage = D3D11_USAGE_DEFAULT;
			depthStencil.BindFlags = D3D11_BIND_DEPTH_STENCIL;
			depthStencil.CPUAccessFlags = 0;
			depthStencil.MiscFlags = 0;
    
			myDepthStencil.Reset(D3D11::Device::CreateTexture2D(myRenderDevice, &depthStencil, nullptr));
			
			::D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilView;
			depthStencilView.Format = depthStencil.Format;
			depthStencilView.Flags = 0;
			depthStencilView.Texture2D.MipSlice = 0;
			
			// Prüfen, ob eine Multisampletextur verwendet werden muss.
			depthStencilView.ViewDimension = backBuffer.SampleDesc.Count > 1 ? 
				::D3D11_DSV_DIMENSION_TEXTURE2DMS :
				::D3D11_DSV_DIMENSION_TEXTURE2D;

			myDepthStencilView.Reset(D3D11::Device::CreateDepthStencilView(
				myRenderDevice, 
				myDepthStencil, 
				&depthStencilView));
		}

		void ReleaseSwapChainDepencies()
		{
			myRenderContext->OMSetRenderTargets(0, nullptr, nullptr);

			myBackBuffer.Reset(nullptr);
			myBackBufferView.Reset(nullptr);
			myDepthStencil.Reset(nullptr);
			myDepthStencilView.Reset(nullptr);
		}

		bool HandlePossibleClientSizeChange()
		{
			auto const clientSize(Windows::GetWindowClientSize(*myWindow));

			if (myClientSize != clientSize)
			{
				myClientSize = clientSize;
				return true;
			}

			return false;
		}

		// Darf keine Ausnahme auslösen.
		void HandlePossibleLostFullscreenState()
		{
			if (::IsIconic(*myWindow) || myLostFullscreenState)
			{
				return;
			}

			// Den Mauszeiger während der Aktion ausblenden.
			Windows::HiddenCursor const hiddenCursor;

			// Wenn im Vollbildmodus der Fensterfokus verloren geht, den Fensterstatus setzen und das Fenster
			// minimieren. Der Vollbildmodus später wiederherstellen, sobald das Fenster den minimierten Status
			// wieder verlässt.
			auto const isFullscreen(DXGI::SwapChain::IsFullscreen(mySwapChain));

			if ((isFullscreen && !myFocusState) || 
				(!isFullscreen && Windows::GetWindowStyle(*myWindow).second == 0))
			{
				mySwapChain->SetFullscreenState(FALSE, nullptr);
				myLostFullscreenState = true;				
						
				::ShowWindow(*myWindow, SW_MINIMIZE);
			}
		}

		void ToggleScreen()
		{
			// Den Mauszeiger während der Aktion ausblenden.
			Windows::HiddenCursor const hiddenCursor;

			if (DXGI::SwapChain::IsFullscreen(mySwapChain))
			{
				// Den vorherigen Fenstermodus wiederherstellen.
				mySwapChain->SetFullscreenState(FALSE, nullptr);								
				Windows::SetWindowStyle(*myWindow, WS_OVERLAPPEDWINDOW, WS_EX_APPWINDOW);
				myWindowPlacement.Set(*myWindow);				
				
				if (HandlePossibleClientSizeChange())
				{
					ReleaseSwapChainDepencies();

					// Die neue Buffergrösse automatisch ermitteln.
					DXGI::SwapChain::ResizeBuffers(
						mySwapChain,
						0,
						0,
						0,
						::DXGI_FORMAT_UNKNOWN,
						::DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);

					InitializeSwapChainDepencies();
				}
			}
			else
			{
				DirectX::Pointer<::IDXGIOutput> const output(DXGI::SwapChain::GetContainingOutput(mySwapChain));

				// Die Vollbildauflösung dem Desktop anpassen auf welchem sich das Fenster gerade befindet.						
				auto const desktop(DXGI::Output::GetDescription(output).DesktopCoordinates);			
				auto const width(static_cast<::UINT>(desktop.right));				
				auto const height(static_cast<::UINT>(desktop.bottom));
												
				// Den Fensterrahmen entfernen damit eine beliebige Klientgrösse gesetzt werden kann.
				// Zuvor den Fensterstatus speichern (Position, Grösse, minimiert, maximiert) damit dieser später
				// wiederhergestellt werden kann.								
				if (Windows::GetWindowStyle(*myWindow).second != 0)
				{
					myWindowPlacement.Get(*myWindow);

					if (::IsIconic(*myWindow) || ::IsZoomed(*myWindow))
					{
						::ShowWindow(*myWindow, SW_RESTORE);
					}
										
					Windows::SetWindowStyle(*myWindow, WS_POPUP, 0);
				}

				Windows::SetWindowClientSize(*myWindow, width, height);
				Windows::CenterWindowAtNearestArea(*myWindow, Windows::Area::Desktop);
				
				// Die Ressourcen müssen auf jeden Fall neu erstellt werden.
				ReleaseSwapChainDepencies();

				if (HandlePossibleClientSizeChange())
				{					
					// Die neue Buffergrösse automatisch ermitteln.
					DXGI::SwapChain::ResizeBuffers(
						mySwapChain,
						0,
						0,
						0,
						::DXGI_FORMAT_UNKNOWN,
						::DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);
				}

				// Bei einem Wechsel in den Vollbildstatus muss IDXGISwapChain::ResizeBuffers() gleich nach
				// IDXGISwapChain::SetFullscreenState() aufgerufen werden auch wenn keine Grössenänderung
				// vorgekommen ist. Ansonsten wird eine IDXGISwapChain::Present() Performancewarnung ausgegeben.				
				DXGI::SwapChain::SetFullscreenState(mySwapChain, true, output);								
				DXGI::SwapChain::ResizeBuffers(
					mySwapChain,
					0,
					0,
					0,
					::DXGI_FORMAT_UNKNOWN,
					::DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH);

				InitializeSwapChainDepencies();
			}
		}

		void Tick()
		{
			myKeyboard.Update();

			if (myKeyboard.IsToggled(VK_ESCAPE))
			{
				myRunningState = false;
			}

			// Alt + Enter -> Fenster- Vollbildmoduswechsel.
			if (myKeyboard.IsDown(VK_MENU) && myKeyboard.IsToggled(VK_RETURN))
			{
				ToggleScreen();
			}
		}

		void Render()
		{
			::FLOAT const clearColor[4] = { 0.0f, 0.125f, 0.3f, 0.0f };
			::UINT const clearFlags(::D3D11_CLEAR_DEPTH | ::D3D11_CLEAR_STENCIL);

			::ID3D11RenderTargetView * const renderTargetViews[1] =
			{
				myBackBufferView.Get()
			};

			myRenderContext->OMSetRenderTargets(1, renderTargetViews, myDepthStencilView);
			myRenderContext->ClearRenderTargetView(myBackBufferView, clearColor);
			myRenderContext->ClearDepthStencilView(myDepthStencilView, clearFlags, 1.0f, 0);

			// Vertikale Synchronisation verwenden.
			myOccludedState = !DXGI::SwapChain::Present(mySwapChain, 1, 0);
		}

	private:
		
		Windows::WindowClass const myWindowClass;
		std::unique_ptr<Windows::Window> myWindow;
		Windows::SizeType myClientSize;
		Windows::WindowPlacement myWindowPlacement;
		Windows::Timer myTimer;
		Windows::Keyboard myKeyboard;

		DirectX::Pointer<::IDXGIFactory1> myGraphicsFactory;
		DirectX::Pointer<::IDXGIAdapter1> myGraphicsAdapter;
		DirectX::Pointer<::ID3D11Device> myRenderDevice;
		DirectX::Pointer<::ID3D11DeviceContext> myRenderContext;
		DirectX::Pointer<::IDXGISwapChain> mySwapChain;
		DirectX::Pointer<::ID3D11Texture2D> myBackBuffer;
		DirectX::Pointer<::ID3D11RenderTargetView> myBackBufferView;
		DirectX::Pointer<::ID3D11Texture2D> myDepthStencil;
		DirectX::Pointer<::ID3D11DepthStencilView> myDepthStencilView;

		bool myValidState;
		bool myRunningState;
		bool myFocusState;
		bool myOccludedState;
		bool myLostFullscreenState;

		float myTime;
		float const myTick;
		float myTickBuffer;
	};
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int WINAPI WinMain(::HINSTANCE moduleInstance, ::HINSTANCE /* unusedInstance */, ::LPSTR /* toCommandLine */, int /* showCommand */)
{
	try
	{
		Test::Application application(moduleInstance);
		::MSG message = { 0 };

		while (application.IsRunning())
		{
			if (::PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE))
			{
				::TranslateMessage(&message);
				::DispatchMessageW(&message);
			}
			else
			{
				application.Update();
			}
		}
	}
	catch (std::exception const & exception)
	{
		::MessageBoxA(
			nullptr,
			exception.what(),
			"Test - Unhandled Exception",
			MB_ICONERROR | 
			MB_SETFOREGROUND);
	}

	return 0;
}