diff --git a/GDP/D3D11/Camera.cpp b/GDP/D3D11/Camera.cpp new file mode 100644 index 0000000..1ad92b8 --- /dev/null +++ b/GDP/D3D11/Camera.cpp @@ -0,0 +1,28 @@ +#include "Camera.h" + +UINT Camera::init(UINT width, UINT height) +{ + // view matrix + XMVECTOR position = XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f); + XMVECTOR forward = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f); + XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f); + XMStoreFloat4x4(&_viewMatrix, XMMatrixLookToLH(position, forward, up)); + + // projection matrix + XMMATRIX perspectiveMatrix = XMMatrixPerspectiveFovLH( + XM_PI * 0.3333333f, // field of view in radians, here 60 degrees + static_cast(width) / static_cast(height), // aspect ratio + 0.3f, 10.0f // near & far clipping planes + ); + XMStoreFloat4x4(&_projectionMatrix, perspectiveMatrix); + + return 0; +} + +void Camera::update(FLOAT dt) +{ +} + +void Camera::deInit() +{ +} diff --git a/GDP/D3D11/Camera.h b/GDP/D3D11/Camera.h new file mode 100644 index 0000000..8faeea4 --- /dev/null +++ b/GDP/D3D11/Camera.h @@ -0,0 +1,22 @@ +#pragma once +#include +#include + +using namespace DirectX; + +class Camera +{ +public: + UINT init(UINT width, UINT height); + void update(FLOAT dt); + void deInit(); + + const XMFLOAT4X4& getViewMatrix() const { return _viewMatrix; } + const XMFLOAT4X4& getProjectionMatrix() const { return _projectionMatrix; } + const XMFLOAT3 getCameraPosition() const { return XMFLOAT3(_viewMatrix._14, _viewMatrix._24, _viewMatrix._34); } + +private: + XMFLOAT4X4 _viewMatrix = {}; + XMFLOAT4X4 _projectionMatrix = {}; +}; + diff --git a/GDP/D3D11/ColorPixelShader.cso b/GDP/D3D11/ColorPixelShader.cso new file mode 100644 index 0000000..662cbf2 Binary files /dev/null and b/GDP/D3D11/ColorPixelShader.cso differ diff --git a/GDP/D3D11/ColorPixelShader.hlsl b/GDP/D3D11/ColorPixelShader.hlsl new file mode 100644 index 0000000..974636a --- /dev/null +++ b/GDP/D3D11/ColorPixelShader.hlsl @@ -0,0 +1,18 @@ +struct PixelInput +{ + float4 position : SV_POSITION; + float4 color : COLOR; +}; + +float4 main(PixelInput INPUT) : SV_TARGET +{ + //return float4(1.0f, 1.0f, 1.0f, 1.0f); // solid color + return INPUT.color; // vertex color + //return INPUT.color * 0.5f; // darker vertex color + //return INPUT.color * 2.0f; // lighter vertex color + + //float4 color = INPUT.color; + //color.r = 0.0f; // no red channel + + //return color; +} \ No newline at end of file diff --git a/GDP/D3D11/ColorVertexShader.cso b/GDP/D3D11/ColorVertexShader.cso new file mode 100644 index 0000000..a2c1f04 Binary files /dev/null and b/GDP/D3D11/ColorVertexShader.cso differ diff --git a/GDP/D3D11/ColorVertexShader.hlsl b/GDP/D3D11/ColorVertexShader.hlsl new file mode 100644 index 0000000..d6225f8 --- /dev/null +++ b/GDP/D3D11/ColorVertexShader.hlsl @@ -0,0 +1,26 @@ +cbuffer MatrixBuffer +{ + matrix WorldViewProjectionMatrix; +}; + +struct VertexInput +{ + float4 position : POSITION; + float4 color : COLOR; +}; + +struct VertexOutput +{ + float4 position : SV_POSITION; + float4 color : COLOR; +}; + +VertexOutput main(VertexInput INPUT) +{ + VertexOutput OUTPUT; + + OUTPUT.position = mul(INPUT.position, WorldViewProjectionMatrix); + OUTPUT.color = INPUT.color; + + return OUTPUT; +} \ No newline at end of file diff --git a/GDP/D3D11/D3D11.vcxproj b/GDP/D3D11/D3D11.vcxproj new file mode 100644 index 0000000..4e9f1a1 --- /dev/null +++ b/GDP/D3D11/D3D11.vcxproj @@ -0,0 +1,297 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + Debug + ARM64 + + + Release + ARM64 + + + + 17.0 + Win32Proj + {C46808CF-936B-4F98-81C2-1E10D9F1822F} + D3D9 + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + + + + + + Level3 + true + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Level3 + true + _DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Level3 + true + true + true + NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Level3 + true + _DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Level3 + true + true + true + NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Pixel + Pixel + Pixel + Pixel + Pixel + Pixel + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + + + Vertex + Vertex + Vertex + Vertex + Vertex + Vertex + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + + + Pixel + Pixel + Pixel + Pixel + Pixel + Pixel + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + + + Vertex + Vertex + Vertex + Vertex + Vertex + Vertex + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + + + Pixel + Pixel + Pixel + Pixel + Pixel + Pixel + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + + + Vertex + Vertex + Vertex + Vertex + Vertex + Vertex + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + %(Filename).cso + + + + + + \ No newline at end of file diff --git a/GDP/D3D11/D3D11.vcxproj.filters b/GDP/D3D11/D3D11.vcxproj.filters new file mode 100644 index 0000000..f6f3674 --- /dev/null +++ b/GDP/D3D11/D3D11.vcxproj.filters @@ -0,0 +1,101 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Resource Files + + + Resource Files + + + Resource Files + + + Resource Files + + + Resource Files + + + Resource Files + + + \ No newline at end of file diff --git a/GDP/D3D11/Direct3D.cpp b/GDP/D3D11/Direct3D.cpp new file mode 100644 index 0000000..8e094e5 --- /dev/null +++ b/GDP/D3D11/Direct3D.cpp @@ -0,0 +1,94 @@ +#include "Direct3D.h" +#include "Utilities.h" + +INT Direct3D::init(HWND hWnd, UINT width, UINT height, BOOL isFullscreen) +{ + HRESULT hr = {}; + + // 1. define swap chain description + DXGI_SWAP_CHAIN_DESC swapChainDesc = {}; + swapChainDesc.OutputWindow = hWnd; // target window instance handle + swapChainDesc.Windowed = !isFullscreen; // windowed or fullscreen + swapChainDesc.BufferCount = 1; // amount of backbuffers, minimum 1 + swapChainDesc.BufferDesc.Width = width; + swapChainDesc.BufferDesc.Height = height; + swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // pixel format, here 4 channels (red, green, blue, alpha) with 8bit depth each and unsigned normalized floating points + swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // which technique is used to render to back buffer + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // what happens to front buffer after swap + swapChainDesc.SampleDesc.Count = 1; // have to be at least one + + // 2. create Direct3D device, device context & swap chain + D3D_FEATURE_LEVEL featureLevels[] = { + D3D_FEATURE_LEVEL_11_1, + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_1, + D3D_FEATURE_LEVEL_10_0 + }; + + D3D_FEATURE_LEVEL chosenFeatureLevel = {}; + + hr = D3D11CreateDeviceAndSwapChain( + nullptr, // graphic card, nullptr -> default adapter + D3D_DRIVER_TYPE_HARDWARE, // rendering with hard- or software renderer + nullptr, // software renderer module reference + 0, // optional flags + featureLevels, std::size(featureLevels), // which api features are supported + D3D11_SDK_VERSION, &swapChainDesc, &_pDXGISwapChain, &_pD3DDevice, &chosenFeatureLevel, &_pD3DDeviceContext); + CheckFailed(hr, 20); + + // 3. create render target + ID3D11Texture2D* pBackBuffer = nullptr; + hr = _pDXGISwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + CheckFailed(hr, 22); + + hr = _pD3DDevice->CreateRenderTargetView(pBackBuffer, nullptr, &_pD3DRenderTargetView); + CheckFailed(hr, 24); + + safeRelease(pBackBuffer); + + // 4. create depth stencil buffer + + // 5. create rasterizer state + //d3d.getDevice()->SetRenderState(D3DRS_LIGHTING, TRUE); +//d3d.getDevice()->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID); +//d3d.getDevice()->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); +//d3d.getDevice()->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL); +//d3d.getDevice()->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL); +//d3d.getDevice()->SetRenderState(D3DRS_SPECULARENABLE, TRUE); + + // 6. describe viewport + D3D11_VIEWPORT viewport = {}; + viewport.TopLeftX = 0.0f; + viewport.TopLeftY = 0.0f; + viewport.Width = width; + viewport.Height = height; + + // 7. setup render pipeline (device context) + _pD3DDeviceContext->OMSetRenderTargets(1, &_pD3DRenderTargetView, nullptr); + _pD3DDeviceContext->RSSetViewports(1, &viewport); + + return 0; +} + +void Direct3D::beginScene(FLOAT r, FLOAT g, FLOAT b) +{ + // clear back buffer with a solid color + FLOAT backgroundColor[] = { r, g, b, 1.0f }; + _pD3DDeviceContext->ClearRenderTargetView(_pD3DRenderTargetView, backgroundColor); +} + +void Direct3D::endScene() +{ + _pDXGISwapChain->Present( + 0, // sync interval, 0,1,2,3,4 -> (de-)active vsync setting and how often should be synced + 0 // optional flags + ); +} + +void Direct3D::deInit() +{ + safeRelease(_pD3DRenderTargetView); + safeRelease(_pDXGISwapChain); + safeRelease(_pD3DDeviceContext); + safeRelease(_pD3DDevice); +} diff --git a/GDP/D3D11/Direct3D.h b/GDP/D3D11/Direct3D.h new file mode 100644 index 0000000..b5f8f15 --- /dev/null +++ b/GDP/D3D11/Direct3D.h @@ -0,0 +1,23 @@ +#pragma once +#include + +#pragma comment(lib, "d3d11.lib") + +class Direct3D +{ +public: + INT init(HWND hWnd, UINT width, UINT height, BOOL isFullscreen); + void beginScene(FLOAT r, FLOAT g, FLOAT b); + void endScene(); + void deInit(); + + ID3D11Device* getDevice() const { return _pD3DDevice; } + ID3D11DeviceContext* getDeviceContext() const { return _pD3DDeviceContext; } + +private: + ID3D11Device* _pD3DDevice = nullptr; // needed for creating all objects, e.g. buffer, textures, etc., used in init phase + ID3D11DeviceContext* _pD3DDeviceContext = nullptr; // access to render pipeline, e.g. set matrices or draw command, used in run phase + IDXGISwapChain* _pDXGISwapChain = nullptr; // holds references to front & back buffer & swaps them + ID3D11RenderTargetView* _pD3DRenderTargetView = nullptr; // target device context is rendering to +}; + diff --git a/GDP/D3D11/Light.cpp b/GDP/D3D11/Light.cpp new file mode 100644 index 0000000..08a5b6f --- /dev/null +++ b/GDP/D3D11/Light.cpp @@ -0,0 +1,33 @@ +#include "Light.h" +#include "Utilities.h" + +UINT Light::init(ID3D11Device* pD3DDevice, LightBuffer& lightData) +{ + D3D11_BUFFER_DESC desc = {}; + desc.ByteWidth = sizeof(LightBuffer); + desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + desc.Usage = D3D11_USAGE_IMMUTABLE; // no light update possible + //desc.Usage = D3D11_USAGE_DYNAMIC; // light update possible + + D3D11_SUBRESOURCE_DATA initialData = {}; + initialData.pSysMem = &lightData; + + HRESULT hr = pD3DDevice->CreateBuffer(&desc, &initialData, &_pLightBuffer); + CheckFailed(hr, 70); + + return 0; +} + +void Light::update(FLOAT dt) +{ +} + +void Light::render(ID3D11DeviceContext* pD3DDeviceContext) +{ + pD3DDeviceContext->PSSetConstantBuffers(0, 1, &_pLightBuffer); +} + +void Light::deInit() +{ + safeRelease(_pLightBuffer); +} diff --git a/GDP/D3D11/Light.h b/GDP/D3D11/Light.h new file mode 100644 index 0000000..b458c9b --- /dev/null +++ b/GDP/D3D11/Light.h @@ -0,0 +1,28 @@ +#pragma once +#include +#include + +using namespace DirectX; + +class Light +{ +public: + struct LightBuffer + { + XMFLOAT3 LightVector; + FLOAT LightIntensity; + XMFLOAT4 DiffuseColor; + XMFLOAT4 SpecularColor; + XMFLOAT3 CameraPosition; + FLOAT Phong; + }; + + UINT init(ID3D11Device* pD3DDevice, LightBuffer& lightData); + void update(FLOAT dt); + void render(ID3D11DeviceContext* pD3DDeviceContext); + void deInit(); + +private: + ID3D11Buffer* _pLightBuffer = nullptr; +}; + diff --git a/GDP/D3D11/LightingPixelShader.cso b/GDP/D3D11/LightingPixelShader.cso new file mode 100644 index 0000000..041c50f Binary files /dev/null and b/GDP/D3D11/LightingPixelShader.cso differ diff --git a/GDP/D3D11/LightingPixelShader.hlsl b/GDP/D3D11/LightingPixelShader.hlsl new file mode 100644 index 0000000..e9d8956 --- /dev/null +++ b/GDP/D3D11/LightingPixelShader.hlsl @@ -0,0 +1,45 @@ +Texture2D MainTexture; +SamplerState MainSampler; + +cbuffer LightBuffer // has to be always 16 byte aligned +{ + float3 LightVector; + float LightIntensity; + float4 DiffuseColor; + float4 SpecularColor; + float3 CameraPosition; + float Phong; +}; + +struct PixelInput +{ + float4 position : SV_POSITION; + float3 positionWorld : POSITION1; + float3 normal : NORMAL; + float2 uv : TEXCOORD; +}; + +float4 main(PixelInput INPUT) : SV_TARGET +{ + float4 texColor = MainTexture.Sample(MainSampler, INPUT.uv); + float4 ambientColor = float4(0.2f, 0.2f, 0.2f, 1.0f); + float4 diffuseColor = DiffuseColor; + float4 specularColor = SpecularColor; + float4 emissionColor = float4(0.0f, 0.0f, 0.0f, 1.0f); + + float3 lightVector = normalize(-LightVector); + float3 normalVector = normalize(INPUT.normal); + + // diffuse color + float diffuse = dot(lightVector, normalVector); // diffuse intensity + diffuseColor *= diffuse * LightIntensity; + + // specular color + float3 reflectVector = normalize(reflect(-lightVector, normalVector)); + //float3 reflectVector = 2 * normalVector * diffuse - lightVector; + float3 viewVector = normalize(CameraPosition - INPUT.positionWorld); + float specular = pow(max(dot(reflectVector, viewVector), 0), Phong); + specularColor *= specular * LightIntensity; + + return saturate(saturate(texColor * saturate(ambientColor + diffuseColor) + specularColor) + emissionColor); +} \ No newline at end of file diff --git a/GDP/D3D11/LightingVertexShader.cso b/GDP/D3D11/LightingVertexShader.cso new file mode 100644 index 0000000..8801e79 Binary files /dev/null and b/GDP/D3D11/LightingVertexShader.cso differ diff --git a/GDP/D3D11/LightingVertexShader.hlsl b/GDP/D3D11/LightingVertexShader.hlsl new file mode 100644 index 0000000..41125c4 --- /dev/null +++ b/GDP/D3D11/LightingVertexShader.hlsl @@ -0,0 +1,33 @@ +cbuffer MatrixBuffer +{ + matrix WorldViewProjectionMatrix; + matrix WorldMatrix; + //float4 TilingOffset; +}; + +struct VertexInput +{ + float4 position : POSITION; + float3 normal : NORMAL; + float2 uv : TEXCOORD; +}; + +struct VertexOutput +{ + float4 position : SV_POSITION; + float3 positionWorld : POSITION1; + float3 normal : NORMAL; + float2 uv : TEXCOORD; +}; + +VertexOutput main(VertexInput INPUT) +{ + VertexOutput OUTPUT; + + OUTPUT.position = mul(INPUT.position, WorldViewProjectionMatrix); + OUTPUT.positionWorld = mul(INPUT.position, WorldMatrix); + OUTPUT.normal = mul(INPUT.normal, (float3x3)WorldMatrix); + OUTPUT.uv = INPUT.uv * float2(1.0f, 1.0f) + float2(0.0f, 0.0f); // uv * tiling + offset + + return OUTPUT; +} \ No newline at end of file diff --git a/GDP/D3D11/Material.cpp b/GDP/D3D11/Material.cpp new file mode 100644 index 0000000..6593ed8 --- /dev/null +++ b/GDP/D3D11/Material.cpp @@ -0,0 +1,194 @@ +#include "Material.h" +#include "Utilities.h" +#include "WICTextureLoader11.h" + +using namespace DirectX; + +UINT Material::init(ID3D11Device* pD3DDevice, LPCTSTR textureFileName) +{ + UINT error = 0; + + error = createVertexShader(pD3DDevice); + CheckError(error); + + error = createPixelShader(pD3DDevice); + CheckError(error); + + error = createMatrixBuffer(pD3DDevice); + CheckError(error); + + error = createTextureAndSamplerState(pD3DDevice, textureFileName); + CheckError(error); + + return 0; +} + +void Material::render(ID3D11DeviceContext* pD3DDeviceContext) +{ + // set shader stages + pD3DDeviceContext->VSSetShader(_pVertexShader, nullptr, 0); + pD3DDeviceContext->PSSetShader(_pPixelShader, nullptr, 0); + + // set input layout + pD3DDeviceContext->IASetInputLayout(_pInputLayout); + + // set shader resources + pD3DDeviceContext->VSSetConstantBuffers(0, 1, &_pMatrixBuffer); + + // set texture + pD3DDeviceContext->PSSetShaderResources(0, 1, &_pTexture); + + // set sampler state + pD3DDeviceContext->PSSetSamplers(0, 1, &_pSamplerState); +} + +void Material::deInit() +{ + safeRelease(_pSamplerState); + safeRelease(_pTexture); + safeRelease(_pMatrixBuffer); + safeRelease(_pInputLayout); + safeRelease(_pPixelShader); + safeRelease(_pVertexShader); +} + +void Material::setMatrixBuffer(ID3D11DeviceContext* pD3DDeviceContext, const XMFLOAT4X4& worldMatrix, const XMFLOAT4X4& viewMatrix, const XMFLOAT4X4& projectionMatrix) +{ + // unpack matrix data + XMMATRIX w = XMLoadFloat4x4(&worldMatrix); + XMMATRIX v = XMLoadFloat4x4(&viewMatrix); + XMMATRIX p = XMLoadFloat4x4(&projectionMatrix); + + XMMATRIX wvp = w * v * p; + + // set matrix data + D3D11_MAPPED_SUBRESOURCE bufferData = {}; + HRESULT hr = pD3DDeviceContext->Map(_pMatrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &bufferData); + if (FAILED(hr)) return; + + MatrixBuffer* matrixBuffer = static_cast(bufferData.pData); + + XMStoreFloat4x4(static_cast(&matrixBuffer->WorldViewProjectionMatrix), XMMatrixTranspose(wvp)); + XMStoreFloat4x4(static_cast(&matrixBuffer->WorldMatrix), XMMatrixTranspose(w)); + + pD3DDeviceContext->Unmap(_pMatrixBuffer, 0); +} + +UINT Material::createVertexShader(ID3D11Device* pD3DDevice) +{ + HRESULT hr = {}; + ID3DBlob* pCompiledShaderCode = nullptr; + + // part 1 get compiled shader code + + // option 1: load high level shader code & compile + //hr = D3DCompileFromFile( + // L"ColorVertexShader.hlsl", // shader file name + // nullptr, // optional macro defines + // nullptr, // pre compiled included shader code + // "main", // shader entry point (start function) + // "vs_4_0", // shader type & version + // 0, 0, // optional flags + // &pCompiledShaderCode, // compiled shader code memory + // nullptr // error messages + //); + + // option 2: load compiled shader code + hr = D3DReadFileToBlob(L"ColorVertexShader.cso", &pCompiledShaderCode); + //hr = D3DReadFileToBlob(L"TextureVertexShader.cso", &pCompiledShaderCode); + //hr = D3DReadFileToBlob(L"LightingVertexShader.cso", &pCompiledShaderCode); + + CheckFailed(hr, 60); + + // part 2 create vertex shader object + hr = pD3DDevice->CreateVertexShader(pCompiledShaderCode->GetBufferPointer(), pCompiledShaderCode->GetBufferSize(), nullptr, &_pVertexShader); + CheckFailed(hr, 62); + + UINT error = createInputLayout(pD3DDevice, pCompiledShaderCode); + CheckError(error); + + safeRelease(pCompiledShaderCode); + + return 0; +} + +UINT Material::createPixelShader(ID3D11Device* pD3DDevice) +{ + HRESULT hr = {}; + ID3DBlob* pCompiledShaderCode = nullptr; + + hr = D3DReadFileToBlob(L"ColorPixelShader.cso", &pCompiledShaderCode); + //hr = D3DReadFileToBlob(L"TexturePixelShader.cso", &pCompiledShaderCode); + //hr = D3DReadFileToBlob(L"LightingPixelShader.cso", &pCompiledShaderCode); + CheckFailed(hr, 64); + + hr = pD3DDevice->CreatePixelShader(pCompiledShaderCode->GetBufferPointer(), pCompiledShaderCode->GetBufferSize(), nullptr, &_pPixelShader); + CheckFailed(hr, 66); + + safeRelease(pCompiledShaderCode); + + return 0; +} + +UINT Material::createInputLayout(ID3D11Device* pD3DDevice, ID3DBlob* pCompiledVertexShaderCode) +{ + // https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-semantics + D3D11_INPUT_ELEMENT_DESC elements[4] = {}; + + // position + elements[0].SemanticName = "POSITION"; + elements[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; + + // normal + elements[1].SemanticName = "NORMAL"; + elements[1].Format = DXGI_FORMAT_R32G32B32_FLOAT; + elements[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; + + // uv + elements[2].SemanticName = "TEXCOORD"; + elements[2].Format = DXGI_FORMAT_R32G32_FLOAT; + elements[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; + + // color + elements[3].SemanticName = "COLOR"; + elements[3].Format = DXGI_FORMAT_R32G32B32A32_FLOAT; + elements[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; + + HRESULT hr = pD3DDevice->CreateInputLayout(elements, std::size(elements), pCompiledVertexShaderCode->GetBufferPointer(), pCompiledVertexShaderCode->GetBufferSize(), &_pInputLayout); + CheckFailed(hr, 68); + + return 0; +} + +UINT Material::createMatrixBuffer(ID3D11Device* pD3DDevice) +{ + D3D11_BUFFER_DESC desc = {}; + desc.ByteWidth = sizeof(MatrixBuffer); + desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + + HRESULT hr = pD3DDevice->CreateBuffer(&desc, nullptr, &_pMatrixBuffer); + CheckFailed(hr, 61); + + return 0; +} + +UINT Material::createTextureAndSamplerState(ID3D11Device* pD3DDevice, LPCTSTR textureFileName) +{ + // load texture + HRESULT hr = CreateWICTextureFromFile(pD3DDevice, textureFileName, nullptr, &_pTexture); + CheckFailed(hr, 63); + + // create sampler state + D3D11_SAMPLER_DESC samplerDesc = {}; + samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; + samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; + samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; // CAUTION: has to be set always + samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + + hr = pD3DDevice->CreateSamplerState(&samplerDesc, &_pSamplerState); + CheckFailed(hr, 65); + + return 0; +} diff --git a/GDP/D3D11/Material.h b/GDP/D3D11/Material.h new file mode 100644 index 0000000..add08c1 --- /dev/null +++ b/GDP/D3D11/Material.h @@ -0,0 +1,40 @@ +#pragma once +#include +#include +#include + +using namespace DirectX; + +#pragma comment(lib, "d3dcompiler.lib") + +class Material +{ +public: + UINT init(ID3D11Device* pD3DDevice, LPCTSTR textureFileName); + void render(ID3D11DeviceContext* pD3DDeviceContext); + void deInit(); + + void setMatrixBuffer(ID3D11DeviceContext* pD3DDeviceContext, const XMFLOAT4X4& worldMatrix, const XMFLOAT4X4& viewMatrix, const XMFLOAT4X4& projectionMatrix); + +private: + UINT createVertexShader(ID3D11Device* pD3DDevice); + UINT createPixelShader(ID3D11Device* pD3DDevice); + UINT createInputLayout(ID3D11Device* pD3DDevice, ID3DBlob* pCompiledVertexShaderCode); + UINT createMatrixBuffer(ID3D11Device* pD3DDevice); + UINT createTextureAndSamplerState(ID3D11Device* pD3DDevice, LPCTSTR textureFileName); + + ID3D11VertexShader* _pVertexShader = nullptr; + ID3D11PixelShader* _pPixelShader = nullptr; + ID3D11InputLayout* _pInputLayout = nullptr; // byte structure of vertex + + struct MatrixBuffer + { + XMFLOAT4X4 WorldViewProjectionMatrix; + XMFLOAT4X4 WorldMatrix; + }; + ID3D11Buffer* _pMatrixBuffer = nullptr; + + ID3D11ShaderResourceView* _pTexture = {}; + ID3D11SamplerState* _pSamplerState = {}; +}; + diff --git a/GDP/D3D11/Mesh.cpp b/GDP/D3D11/Mesh.cpp new file mode 100644 index 0000000..8c0472c --- /dev/null +++ b/GDP/D3D11/Mesh.cpp @@ -0,0 +1,129 @@ +#include "Mesh.h" +#include "Utilities.h" +#include "Vertex.h" +#include + +using namespace DirectX; + +UINT Mesh::init(ID3D11Device* pD3DDevice) +{ + UINT error = 0; + + error = createVertexBuffer(pD3DDevice); + CheckError(error); + + error = createIndexBuffer(pD3DDevice); + CheckError(error); + + // create world matrix + XMStoreFloat4x4(&_worldMatrix, XMMatrixIdentity()); + + return 0; +} + +void Mesh::update(FLOAT dt) +{ + static FLOAT x = 0.0f; + static FLOAT y = 0.0f; + static FLOAT z = 0.0f; + static FLOAT rot = 0.0f; + rot += 1.0f * dt; + + FLOAT move = 1.0f * dt; + + if ((GetAsyncKeyState(VK_LEFT) & 0x8000) || (GetAsyncKeyState('A') & 0x8000)) x -= move; + if ((GetAsyncKeyState(VK_RIGHT) & 0x8000) || (GetAsyncKeyState('D') & 0x8000)) x += move; + if ((GetAsyncKeyState(VK_UP) & 0x8000) || (GetAsyncKeyState('W') & 0x8000)) y += move; + if ((GetAsyncKeyState(VK_DOWN) & 0x8000) || (GetAsyncKeyState('S') & 0x8000)) y -= move; + if ((GetAsyncKeyState(VK_ADD) & 0x8000) || (GetAsyncKeyState('Q') & 0x8000)) z -= move; + if ((GetAsyncKeyState(VK_SUBTRACT) & 0x8000) || (GetAsyncKeyState('E') & 0x8000)) z += move; + + XMMATRIX translation = XMMatrixTranslation(x, y, z); + XMMATRIX rotation = XMMatrixRotationRollPitchYaw(0.0f, 0.0f, 0.0f); + XMMATRIX scale = XMMatrixScaling(1.0f, 1.0f, 1.0f); + + XMVECTOR det = XMMatrixDeterminant(translation); + + XMStoreFloat4x4(&_worldMatrix, scale * rotation * translation); +} + +void Mesh::render(ID3D11DeviceContext* pD3DDeviceContext) +{ + // set data + static UINT offset = 0; + pD3DDeviceContext->IASetVertexBuffers(0, 1, &_pVertexBuffer, &_vertexStride, &offset); + pD3DDeviceContext->IASetIndexBuffer(_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0); + pD3DDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + + // draw + pD3DDeviceContext->DrawIndexed(_indexCount, 0, 0); +} + +void Mesh::deInit() +{ + safeRelease(_pIndexBuffer); + safeRelease(_pVertexBuffer); +} + +UINT Mesh::createVertexBuffer(ID3D11Device* pD3DDevice) +{ + // describe vertex buffer content + // quad with color + Vertex vertices[] = { Vertex(-0.5f, 0.5f, 0.0f, 255, 0, 0), + Vertex(0.5f, 0.5f, 0.0f, 0, 255, 0), + Vertex(0.5f, -0.5f, 0.0f, 255, 0, 255), + Vertex(-0.5f, -0.5f, 0.0f, 0, 0, 255) }; + + + // quad with uv & normal + //Vertex vertices[] = { + // Vertex(-0.5f, 0.5f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f), + // Vertex(0.5f, 0.5f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f), + // Vertex(0.5f, -0.5f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f), + // Vertex(-0.5f, -0.5f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f) + //}; + + // general data + _vertexCount = std::size(vertices); + _vertexStride = sizeof(Vertex); + + // create vertex buffer object + D3D11_BUFFER_DESC desc = {}; + desc.ByteWidth = _vertexCount * _vertexStride; // size of vertex buffer in bytes + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.Usage = D3D11_USAGE_IMMUTABLE; // https://learn.microsoft.com/en-us/windows/win32/api/d3d11/ne-d3d11-d3d11_usage + + D3D11_SUBRESOURCE_DATA data = {}; + data.pSysMem = vertices; + + HRESULT hr = pD3DDevice->CreateBuffer(&desc, &data, &_pVertexBuffer); + CheckFailed(hr, 30); + + return 0; +} + +UINT Mesh::createIndexBuffer(ID3D11Device* pD3DDevice) +{ + // describe index buffer content + WORD indices[] = { + 0,1,2, + 0,2,3 + }; + + // general data + _indexCount = std::size(indices); + + // create index buffer object + D3D11_BUFFER_DESC desc = {}; + desc.ByteWidth = _indexCount * sizeof(WORD); // size of index buffer in bytes + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.Usage = D3D11_USAGE_IMMUTABLE; + + D3D11_SUBRESOURCE_DATA data = {}; + data.pSysMem = indices; + + HRESULT hr = pD3DDevice->CreateBuffer(&desc, &data, &_pIndexBuffer); + CheckFailed(hr, 32); + + return 0; +} diff --git a/GDP/D3D11/Mesh.h b/GDP/D3D11/Mesh.h new file mode 100644 index 0000000..5f30f23 --- /dev/null +++ b/GDP/D3D11/Mesh.h @@ -0,0 +1,30 @@ +#pragma once +#include +#include + +using namespace DirectX; + +class Mesh +{ +public: + UINT init(ID3D11Device* pD3DDevice); + void update(FLOAT dt); + void render(ID3D11DeviceContext* pD3DDeviceContext); + void deInit(); + + const XMFLOAT4X4& getWorldMatrix() const { return _worldMatrix; } + +private: + UINT createVertexBuffer(ID3D11Device* pD3DDevice); + UINT createIndexBuffer(ID3D11Device* pD3DDevice); + + ID3D11Buffer* _pVertexBuffer = nullptr; // dumps mesh vertices + ID3D11Buffer* _pIndexBuffer = nullptr; // dumps mesh indices + + UINT _vertexCount = 0; // amount of vertices + UINT _vertexStride = 0; // size of one vertex in bytes + UINT _indexCount = 0; // amount of indices + + XMFLOAT4X4 _worldMatrix = {}; +}; + diff --git a/GDP/D3D11/TexturePixelShader.cso b/GDP/D3D11/TexturePixelShader.cso new file mode 100644 index 0000000..fa02e73 Binary files /dev/null and b/GDP/D3D11/TexturePixelShader.cso differ diff --git a/GDP/D3D11/TexturePixelShader.hlsl b/GDP/D3D11/TexturePixelShader.hlsl new file mode 100644 index 0000000..e532538 --- /dev/null +++ b/GDP/D3D11/TexturePixelShader.hlsl @@ -0,0 +1,13 @@ +Texture2D MainTexture; +SamplerState MainSampler; + +struct PixelInput +{ + float4 position : SV_POSITION; + float2 uv : TEXCOORD; +}; + +float4 main(PixelInput INPUT) : SV_TARGET +{ + return MainTexture.Sample(MainSampler, INPUT.uv); +} \ No newline at end of file diff --git a/GDP/D3D11/TextureVertexShader.cso b/GDP/D3D11/TextureVertexShader.cso new file mode 100644 index 0000000..8ff453a Binary files /dev/null and b/GDP/D3D11/TextureVertexShader.cso differ diff --git a/GDP/D3D11/TextureVertexShader.hlsl b/GDP/D3D11/TextureVertexShader.hlsl new file mode 100644 index 0000000..3ab7e86 --- /dev/null +++ b/GDP/D3D11/TextureVertexShader.hlsl @@ -0,0 +1,27 @@ +cbuffer MatrixBuffer +{ + matrix WorldViewProjectionMatrix; + //float4 TilingOffset; +}; + +struct VertexInput +{ + float4 position : POSITION; + float2 uv : TEXCOORD; +}; + +struct VertexOutput +{ + float4 position : SV_POSITION; + float2 uv : TEXCOORD; +}; + +VertexOutput main(VertexInput INPUT) +{ + VertexOutput OUTPUT; + + OUTPUT.position = mul(INPUT.position, WorldViewProjectionMatrix); + OUTPUT.uv = INPUT.uv * float2(1.0f, 1.0f) + float2(0.0f, 0.0f); // uv * tiling + offset + + return OUTPUT; +} \ No newline at end of file diff --git a/GDP/D3D11/Time.cpp b/GDP/D3D11/Time.cpp new file mode 100644 index 0000000..7fabc0e --- /dev/null +++ b/GDP/D3D11/Time.cpp @@ -0,0 +1,34 @@ +#include "Time.h" +#include + +UINT Time::init() +{ + _lastTime = CLOCK::now(); + + return 0; +} + +void Time::update() +{ + TIME_POINT now = CLOCK::now(); + SECONDS diff = now - _lastTime; + _deltaTime = diff.count(); + _lastTime = now; + +#ifdef _DEBUG +#ifdef UNICODE + wstring output = L"fps: " + to_wstring(1 / _deltaTime) + L"\n"; + OutputDebugString(output.c_str()); +#else // !UNICODE + string output = "fps: " + to_string(1 / _deltaTime) + "\n"; + OutputDebugString(output.c_str()); +#endif // UNICODE + + +#endif // DEBUG + +} + +void Time::deInit() +{ +} diff --git a/GDP/D3D11/Time.h b/GDP/D3D11/Time.h new file mode 100644 index 0000000..da30a91 --- /dev/null +++ b/GDP/D3D11/Time.h @@ -0,0 +1,24 @@ +#pragma once +#include +#include + +using namespace std; + +typedef chrono::steady_clock CLOCK; +typedef CLOCK::time_point TIME_POINT; +typedef chrono::duration SECONDS; + +class Time +{ +public: + UINT init(); + void update(); + void deInit(); + + FLOAT getDeltaTime() const { return _deltaTime; } + +private: + FLOAT _deltaTime = 0.0f; + TIME_POINT _lastTime = {}; +}; + diff --git a/GDP/D3D11/Utilities.cpp b/GDP/D3D11/Utilities.cpp new file mode 100644 index 0000000..d879387 --- /dev/null +++ b/GDP/D3D11/Utilities.cpp @@ -0,0 +1,14 @@ +#include "Utilities.h" + +void ShowError(UINT error) +{ +#if _DEBUG + LPCTSTR msg = TEXT("Application quit with an error: "); +#if UNICODE + msg = (std::wstring(msg) + std::to_wstring(error)).c_str(); +#else // UNICODE + msg = (std::string(msg) + std::to_string(error)).c_str(); +#endif // UNICODE + MessageBox(nullptr, msg, TEXT("Error"), MB_OK); +#endif // DEBUG +} diff --git a/GDP/D3D11/Utilities.h b/GDP/D3D11/Utilities.h new file mode 100644 index 0000000..c6d2ed8 --- /dev/null +++ b/GDP/D3D11/Utilities.h @@ -0,0 +1,27 @@ +#pragma once +#include +#include + +void ShowError(UINT error); + +#define CheckError(x) if (x != 0) \ +{ \ + ShowError(x); \ + return x; \ +} + +#define CheckFailed(hr, x) if (FAILED(hr)) \ +{ \ + ShowError(x); \ + return x; \ +} + +template +void safeRelease(T*& obj) +{ + if (obj != nullptr) + { + obj->Release(); + obj = nullptr; + } +} \ No newline at end of file diff --git a/GDP/D3D11/Vertex.h b/GDP/D3D11/Vertex.h new file mode 100644 index 0000000..131dd0a --- /dev/null +++ b/GDP/D3D11/Vertex.h @@ -0,0 +1,20 @@ +#pragma once +#include +#include + +using namespace DirectX; + +struct Vertex +{ + XMFLOAT3 position; + XMFLOAT3 normal; + XMFLOAT2 uv; + XMFLOAT4 color; + + Vertex() : position(0.0f, 0.0f, 0.0f), normal(0.0f, 0.0f, 0.0f), uv(0.0f, 0.0f), color(1.0f, 1.0f, 1.0f, 1.0f) {} + Vertex(FLOAT x, FLOAT y, FLOAT z) : position(x, y, z), normal(0.0f, 0.0f, 0.0f), uv(0.0f, 0.0f), color(1.0f, 1.0f, 1.0f, 1.0f) {} + Vertex(FLOAT x, FLOAT y, FLOAT z, UINT r, UINT g, UINT b) + : position(x, y, z), normal(0.0f, 0.0f, 0.0f), uv(0.0f, 0.0f), color(r / 255.0f, g / 255.0f, b / 255.0f, 1.0f) {} + Vertex(FLOAT x, FLOAT y, FLOAT z, FLOAT u, FLOAT v) : position(x, y, z), normal(0.0f, 0.0f, 0.0f), uv(u, v), color(1.0f, 1.0f, 1.0f, 1.0f) {} + Vertex(FLOAT x, FLOAT y, FLOAT z, FLOAT nx, FLOAT ny, FLOAT nz, FLOAT u, FLOAT v) : position(x, y, z), normal(nx, ny, nz), uv(u, v), color(1.0f, 1.0f, 1.0f, 1.0f) {} +}; \ No newline at end of file diff --git a/GDP/D3D11/WICTextureLoader11.cpp b/GDP/D3D11/WICTextureLoader11.cpp new file mode 100644 index 0000000..32f8fd5 --- /dev/null +++ b/GDP/D3D11/WICTextureLoader11.cpp @@ -0,0 +1,1096 @@ +//-------------------------------------------------------------------------------------- +// File: WICTextureLoader11.cpp +// +// Function for loading a WIC image and creating a Direct3D runtime texture for it +// (auto-generating mipmaps if possible) +// +// Note: Assumes application has already called CoInitializeEx +// +// Warning: CreateWICTexture* functions are not thread-safe if given a d3dContext instance for +// auto-gen mipmap support. +// +// Note these functions are useful for images created as simple 2D textures. For +// more complex resources, DDSTextureLoader is an excellent light-weight runtime loader. +// For a full-featured DDS file reader, writer, and texture processing pipeline see +// the 'Texconv' sample and the 'DirectXTex' library. +// +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// http://go.microsoft.com/fwlink/?LinkId=248926 +// http://go.microsoft.com/fwlink/?LinkId=248929 +//-------------------------------------------------------------------------------------- + +// We could load multi-frame images (TIFF/GIF) into a texture array. +// For now, we just load the first frame (note: DirectXTex supports multi-frame images) + +#include "WICTextureLoader11.h" + +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +// Off by default warnings +#pragma warning(disable : 4619 4616 4061 4062 4623 4626 5027) +// C4619/4616 #pragma warning warnings +// C4061 enumerator 'x' in switch of enum 'y' is not explicitly handled by a case label +// C4062 enumerator 'x' in switch of enum 'y' is not handled +// C4623 default constructor was implicitly defined as deleted +// C4626 assignment operator was implicitly defined as deleted +// C5027 move assignment operator was implicitly defined as deleted +#endif + +#ifdef __clang__ +#pragma clang diagnostic ignored "-Wcovered-switch-default" +#pragma clang diagnostic ignored "-Wswitch-enum" +#endif + +using namespace DirectX; +using Microsoft::WRL::ComPtr; + +namespace +{ + //-------------------------------------------------------------------------------------- +#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) + template + inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_ const char(&name)[TNameLength]) noexcept + { + resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name); + } +#else + template + inline void SetDebugObjectName(_In_ ID3D11DeviceChild*, _In_ const char(&)[TNameLength]) noexcept + { + } +#endif + + //------------------------------------------------------------------------------------- + // WIC Pixel Format Translation Data + //------------------------------------------------------------------------------------- + struct WICTranslate + { + const GUID& wic; + DXGI_FORMAT format; + + constexpr WICTranslate(const GUID& wg, DXGI_FORMAT fmt) noexcept : + wic(wg), + format(fmt) { + } + }; + + constexpr WICTranslate g_WICFormats[] = + { + { GUID_WICPixelFormat128bppRGBAFloat, DXGI_FORMAT_R32G32B32A32_FLOAT }, + + { GUID_WICPixelFormat64bppRGBAHalf, DXGI_FORMAT_R16G16B16A16_FLOAT }, + { GUID_WICPixelFormat64bppRGBA, DXGI_FORMAT_R16G16B16A16_UNORM }, + + { GUID_WICPixelFormat32bppRGBA, DXGI_FORMAT_R8G8B8A8_UNORM }, + { GUID_WICPixelFormat32bppBGRA, DXGI_FORMAT_B8G8R8A8_UNORM }, // DXGI 1.1 + { GUID_WICPixelFormat32bppBGR, DXGI_FORMAT_B8G8R8X8_UNORM }, // DXGI 1.1 + + { GUID_WICPixelFormat32bppRGBA1010102XR, DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM }, // DXGI 1.1 + { GUID_WICPixelFormat32bppRGBA1010102, DXGI_FORMAT_R10G10B10A2_UNORM }, + + { GUID_WICPixelFormat16bppBGRA5551, DXGI_FORMAT_B5G5R5A1_UNORM }, + { GUID_WICPixelFormat16bppBGR565, DXGI_FORMAT_B5G6R5_UNORM }, + + { GUID_WICPixelFormat32bppGrayFloat, DXGI_FORMAT_R32_FLOAT }, + { GUID_WICPixelFormat16bppGrayHalf, DXGI_FORMAT_R16_FLOAT }, + { GUID_WICPixelFormat16bppGray, DXGI_FORMAT_R16_UNORM }, + { GUID_WICPixelFormat8bppGray, DXGI_FORMAT_R8_UNORM }, + + { GUID_WICPixelFormat8bppAlpha, DXGI_FORMAT_A8_UNORM }, + }; + + //------------------------------------------------------------------------------------- + // WIC Pixel Format nearest conversion table + //------------------------------------------------------------------------------------- + struct WICConvert + { + const GUID& source; + const GUID& target; + + constexpr WICConvert(const GUID& src, const GUID& tgt) noexcept : + source(src), + target(tgt) { + } + }; + + constexpr WICConvert g_WICConvert[] = + { + // Note target GUID in this conversion table must be one of those directly supported formats (above). + + { GUID_WICPixelFormatBlackWhite, GUID_WICPixelFormat8bppGray }, // DXGI_FORMAT_R8_UNORM + + { GUID_WICPixelFormat1bppIndexed, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat2bppIndexed, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat4bppIndexed, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat8bppIndexed, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + + { GUID_WICPixelFormat2bppGray, GUID_WICPixelFormat8bppGray }, // DXGI_FORMAT_R8_UNORM + { GUID_WICPixelFormat4bppGray, GUID_WICPixelFormat8bppGray }, // DXGI_FORMAT_R8_UNORM + + { GUID_WICPixelFormat16bppGrayFixedPoint, GUID_WICPixelFormat16bppGrayHalf }, // DXGI_FORMAT_R16_FLOAT + { GUID_WICPixelFormat32bppGrayFixedPoint, GUID_WICPixelFormat32bppGrayFloat }, // DXGI_FORMAT_R32_FLOAT + + { GUID_WICPixelFormat16bppBGR555, GUID_WICPixelFormat16bppBGRA5551 }, // DXGI_FORMAT_B5G5R5A1_UNORM + + { GUID_WICPixelFormat32bppBGR101010, GUID_WICPixelFormat32bppRGBA1010102 }, // DXGI_FORMAT_R10G10B10A2_UNORM + + { GUID_WICPixelFormat24bppBGR, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat24bppRGB, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat32bppPBGRA, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat32bppPRGBA, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + + { GUID_WICPixelFormat48bppRGB, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + { GUID_WICPixelFormat48bppBGR, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + { GUID_WICPixelFormat64bppBGRA, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + { GUID_WICPixelFormat64bppPRGBA, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + { GUID_WICPixelFormat64bppPBGRA, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + + { GUID_WICPixelFormat48bppRGBFixedPoint, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + { GUID_WICPixelFormat48bppBGRFixedPoint, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + { GUID_WICPixelFormat64bppRGBAFixedPoint, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + { GUID_WICPixelFormat64bppBGRAFixedPoint, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + { GUID_WICPixelFormat64bppRGBFixedPoint, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + { GUID_WICPixelFormat64bppRGBHalf, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + { GUID_WICPixelFormat48bppRGBHalf, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + + { GUID_WICPixelFormat128bppPRGBAFloat, GUID_WICPixelFormat128bppRGBAFloat }, // DXGI_FORMAT_R32G32B32A32_FLOAT + { GUID_WICPixelFormat128bppRGBFloat, GUID_WICPixelFormat128bppRGBAFloat }, // DXGI_FORMAT_R32G32B32A32_FLOAT + { GUID_WICPixelFormat128bppRGBAFixedPoint, GUID_WICPixelFormat128bppRGBAFloat }, // DXGI_FORMAT_R32G32B32A32_FLOAT + { GUID_WICPixelFormat128bppRGBFixedPoint, GUID_WICPixelFormat128bppRGBAFloat }, // DXGI_FORMAT_R32G32B32A32_FLOAT + { GUID_WICPixelFormat32bppRGBE, GUID_WICPixelFormat128bppRGBAFloat }, // DXGI_FORMAT_R32G32B32A32_FLOAT + + { GUID_WICPixelFormat32bppCMYK, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat64bppCMYK, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + { GUID_WICPixelFormat40bppCMYKAlpha, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat80bppCMYKAlpha, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + + #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) + { GUID_WICPixelFormat32bppRGB, GUID_WICPixelFormat32bppRGBA }, // DXGI_FORMAT_R8G8B8A8_UNORM + { GUID_WICPixelFormat64bppRGB, GUID_WICPixelFormat64bppRGBA }, // DXGI_FORMAT_R16G16B16A16_UNORM + { GUID_WICPixelFormat64bppPRGBAHalf, GUID_WICPixelFormat64bppRGBAHalf }, // DXGI_FORMAT_R16G16B16A16_FLOAT + #endif + + // We don't support n-channel formats + }; + +#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) + bool g_WIC2 = false; +#endif + + BOOL WINAPI InitializeWICFactory(PINIT_ONCE, PVOID, PVOID* ifactory) noexcept + { +#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) + HRESULT hr = CoCreateInstance( + CLSID_WICImagingFactory2, + nullptr, + CLSCTX_INPROC_SERVER, + __uuidof(IWICImagingFactory2), + ifactory + ); + + if (SUCCEEDED(hr)) + { + // WIC2 is available on Windows 10, Windows 8.x, and Windows 7 SP1 with KB 2670838 installed + g_WIC2 = true; + return TRUE; + } + else + { + hr = CoCreateInstance( + CLSID_WICImagingFactory1, + nullptr, + CLSCTX_INPROC_SERVER, + __uuidof(IWICImagingFactory), + ifactory + ); + return SUCCEEDED(hr) ? TRUE : FALSE; + } +#else + return SUCCEEDED(CoCreateInstance( + CLSID_WICImagingFactory, + nullptr, + CLSCTX_INPROC_SERVER, + __uuidof(IWICImagingFactory), + ifactory)) ? TRUE : FALSE; +#endif + } + + IWICImagingFactory* GetWIC() noexcept + { + static INIT_ONCE s_initOnce = INIT_ONCE_STATIC_INIT; + + IWICImagingFactory* factory = nullptr; + if (!InitOnceExecuteOnce( + &s_initOnce, + InitializeWICFactory, + nullptr, + reinterpret_cast(&factory))) + { + return nullptr; + } + + return factory; + } + + //--------------------------------------------------------------------------------- + DXGI_FORMAT WICToDXGI(const GUID& guid) noexcept + { + for (size_t i = 0; i < std::size(g_WICFormats); ++i) + { + if (memcmp(&g_WICFormats[i].wic, &guid, sizeof(GUID)) == 0) + return g_WICFormats[i].format; + } + +#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) + if (g_WIC2) + { + if (memcmp(&GUID_WICPixelFormat96bppRGBFloat, &guid, sizeof(GUID)) == 0) + return DXGI_FORMAT_R32G32B32_FLOAT; + } +#endif + + return DXGI_FORMAT_UNKNOWN; + } + + //--------------------------------------------------------------------------------- + size_t WICBitsPerPixel(REFGUID targetGuid) noexcept + { + auto pWIC = GetWIC(); + if (!pWIC) + return 0; + + ComPtr cinfo; + if (FAILED(pWIC->CreateComponentInfo(targetGuid, cinfo.GetAddressOf()))) + return 0; + + WICComponentType type; + if (FAILED(cinfo->GetComponentType(&type))) + return 0; + + if (type != WICPixelFormat) + return 0; + + ComPtr pfinfo; + if (FAILED(cinfo.As(&pfinfo))) + return 0; + + UINT bpp; + if (FAILED(pfinfo->GetBitsPerPixel(&bpp))) + return 0; + + return bpp; + } + + + //-------------------------------------------------------------------------------------- + DXGI_FORMAT MakeSRGB(_In_ DXGI_FORMAT format) noexcept + { + switch (format) + { + case DXGI_FORMAT_R8G8B8A8_UNORM: + return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + + case DXGI_FORMAT_BC1_UNORM: + return DXGI_FORMAT_BC1_UNORM_SRGB; + + case DXGI_FORMAT_BC2_UNORM: + return DXGI_FORMAT_BC2_UNORM_SRGB; + + case DXGI_FORMAT_BC3_UNORM: + return DXGI_FORMAT_BC3_UNORM_SRGB; + + case DXGI_FORMAT_B8G8R8A8_UNORM: + return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; + + case DXGI_FORMAT_B8G8R8X8_UNORM: + return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB; + + case DXGI_FORMAT_BC7_UNORM: + return DXGI_FORMAT_BC7_UNORM_SRGB; + + default: + return format; + } + } + + + //--------------------------------------------------------------------------------- + void FitPowerOf2(UINT origx, UINT origy, UINT& targetx, UINT& targety, size_t maxsize) + { + const float origAR = float(origx) / float(origy); + + if (origx > origy) + { + size_t x; + for (x = maxsize; x > 1; x >>= 1) { if (x <= targetx) break; } + targetx = UINT(x); + + float bestScore = FLT_MAX; + for (size_t y = maxsize; y > 0; y >>= 1) + { + const float score = fabsf((float(x) / float(y)) - origAR); + if (score < bestScore) + { + bestScore = score; + targety = UINT(y); + } + } + } + else + { + size_t y; + for (y = maxsize; y > 1; y >>= 1) { if (y <= targety) break; } + targety = UINT(y); + + float bestScore = FLT_MAX; + for (size_t x = maxsize; x > 0; x >>= 1) + { + const float score = fabsf((float(x) / float(y)) - origAR); + if (score < bestScore) + { + bestScore = score; + targetx = UINT(x); + } + } + } + } + + + //--------------------------------------------------------------------------------- + HRESULT CreateTextureFromWIC(_In_ ID3D11Device* d3dDevice, + _In_opt_ ID3D11DeviceContext* d3dContext, + _In_ IWICBitmapFrameDecode* frame, + _In_ size_t maxsize, + _In_ D3D11_USAGE usage, + _In_ unsigned int bindFlags, + _In_ unsigned int cpuAccessFlags, + _In_ unsigned int miscFlags, + _In_ WIC_LOADER_FLAGS loadFlags, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept + { + UINT width, height; + HRESULT hr = frame->GetSize(&width, &height); + if (FAILED(hr)) + return hr; + + if (maxsize > UINT32_MAX) + return E_INVALIDARG; + + assert(width > 0 && height > 0); + + if (!maxsize) + { + // This is a bit conservative because the hardware could support larger textures than + // the Feature Level defined minimums, but doing it this way is much easier and more + // performant for WIC than the 'fail and retry' model used by DDSTextureLoader + + switch (d3dDevice->GetFeatureLevel()) + { + case D3D_FEATURE_LEVEL_9_1: + case D3D_FEATURE_LEVEL_9_2: + maxsize = 2048u /*D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION*/; + break; + + case D3D_FEATURE_LEVEL_9_3: + maxsize = 4096u /*D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION*/; + break; + + case D3D_FEATURE_LEVEL_10_0: + case D3D_FEATURE_LEVEL_10_1: + maxsize = 8192u /*D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION*/; + break; + + default: + maxsize = size_t(D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION); + break; + } + } + + assert(maxsize > 0); + + UINT twidth = width; + UINT theight = height; + if (loadFlags & WIC_LOADER_FIT_POW2) + { + FitPowerOf2(width, height, twidth, theight, maxsize); + } + else if (width > maxsize || height > maxsize) + { + const float ar = static_cast(height) / static_cast(width); + if (width > height) + { + twidth = static_cast(maxsize); + theight = std::max(1, static_cast(static_cast(maxsize) * ar)); + } + else + { + theight = static_cast(maxsize); + twidth = std::max(1, static_cast(static_cast(maxsize) / ar)); + } + assert(twidth <= maxsize && theight <= maxsize); + } + + if (loadFlags & WIC_LOADER_MAKE_SQUARE) + { + twidth = std::max(twidth, theight); + theight = twidth; + } + + // Determine format + WICPixelFormatGUID pixelFormat; + hr = frame->GetPixelFormat(&pixelFormat); + if (FAILED(hr)) + return hr; + + WICPixelFormatGUID convertGUID; + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &pixelFormat, sizeof(GUID)); + + size_t bpp = 0; + + DXGI_FORMAT format = WICToDXGI(pixelFormat); + if (format == DXGI_FORMAT_UNKNOWN) + { + if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0) + { +#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) + if (g_WIC2) + { + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID)); + format = DXGI_FORMAT_R32G32B32_FLOAT; + bpp = 96; + } + else +#endif + { + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID)); + format = DXGI_FORMAT_R32G32B32A32_FLOAT; + bpp = 128; + } + } + else + { + for (size_t i = 0; i < std::size(g_WICConvert); ++i) + { + if (memcmp(&g_WICConvert[i].source, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0) + { + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &g_WICConvert[i].target, sizeof(GUID)); + + format = WICToDXGI(g_WICConvert[i].target); + assert(format != DXGI_FORMAT_UNKNOWN); + bpp = WICBitsPerPixel(convertGUID); + break; + } + } + } + + if (format == DXGI_FORMAT_UNKNOWN) + return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); + } + else + { + bpp = WICBitsPerPixel(pixelFormat); + } + +#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE) + if ((format == DXGI_FORMAT_R32G32B32_FLOAT) && d3dContext && textureView) + { + // Special case test for optional device support for autogen mipchains for R32G32B32_FLOAT + UINT fmtSupport = 0; + hr = d3dDevice->CheckFormatSupport(DXGI_FORMAT_R32G32B32_FLOAT, &fmtSupport); + if (FAILED(hr) || !(fmtSupport & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN)) + { + // Use R32G32B32A32_FLOAT instead which is required for Feature Level 10.0 and up + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID)); + format = DXGI_FORMAT_R32G32B32A32_FLOAT; + bpp = 128; + } + } +#endif + + if (loadFlags & WIC_LOADER_FORCE_RGBA32) + { + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat32bppRGBA, sizeof(GUID)); + format = DXGI_FORMAT_R8G8B8A8_UNORM; + bpp = 32; + } + + if (!bpp) + return E_FAIL; + + // Handle sRGB formats + if (loadFlags & WIC_LOADER_FORCE_SRGB) + { + format = MakeSRGB(format); + } + else if (!(loadFlags & WIC_LOADER_IGNORE_SRGB)) + { + ComPtr metareader; + if (SUCCEEDED(frame->GetMetadataQueryReader(metareader.GetAddressOf()))) + { + GUID containerFormat; + if (SUCCEEDED(metareader->GetContainerFormat(&containerFormat))) + { + bool sRGB = false; + + PROPVARIANT value; + PropVariantInit(&value); + + // Check for colorspace chunks + if (memcmp(&containerFormat, &GUID_ContainerFormatPng, sizeof(GUID)) == 0) + { + if (SUCCEEDED(metareader->GetMetadataByName(L"/sRGB/RenderingIntent", &value)) && value.vt == VT_UI1) + { + sRGB = true; + } + else if (SUCCEEDED(metareader->GetMetadataByName(L"/gAMA/ImageGamma", &value)) && value.vt == VT_UI4) + { + sRGB = (value.uintVal == 45455); + } + else + { + sRGB = (loadFlags & WIC_LOADER_SRGB_DEFAULT) != 0; + } + } + else if (SUCCEEDED(metareader->GetMetadataByName(L"System.Image.ColorSpace", &value)) && value.vt == VT_UI2) + { + sRGB = (value.uiVal == 1); + } + else + { + sRGB = (loadFlags & WIC_LOADER_SRGB_DEFAULT) != 0; + } + + std::ignore = PropVariantClear(&value); + + if (sRGB) + format = MakeSRGB(format); + } + } + } + + // Verify our target format is supported by the current device + // (handles WDDM 1.0 or WDDM 1.1 device driver cases as well as DirectX 11.0 Runtime without 16bpp format support) + UINT support = 0; + hr = d3dDevice->CheckFormatSupport(format, &support); + if (FAILED(hr) || !(support & D3D11_FORMAT_SUPPORT_TEXTURE2D)) + { + // Fallback to RGBA 32-bit format which is supported by all devices + memcpy_s(&convertGUID, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat32bppRGBA, sizeof(GUID)); + format = DXGI_FORMAT_R8G8B8A8_UNORM; + bpp = 32; + } + + // Allocate temporary memory for image + const uint64_t rowBytes = (uint64_t(twidth) * uint64_t(bpp) + 7u) / 8u; + const uint64_t numBytes = rowBytes * uint64_t(theight); + + if (rowBytes > UINT32_MAX || numBytes > UINT32_MAX) + return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW); + + auto const rowPitch = static_cast(rowBytes); + auto const imageSize = static_cast(numBytes); + + std::unique_ptr temp(new (std::nothrow) uint8_t[imageSize]); + if (!temp) + return E_OUTOFMEMORY; + + // Load image data + if (memcmp(&convertGUID, &pixelFormat, sizeof(GUID)) == 0 + && twidth == width + && theight == height) + { + // No format conversion or resize needed + hr = frame->CopyPixels(nullptr, static_cast(rowPitch), static_cast(imageSize), temp.get()); + if (FAILED(hr)) + return hr; + } + else if (twidth != width || theight != height) + { + // Resize + auto pWIC = GetWIC(); + if (!pWIC) + return E_NOINTERFACE; + + ComPtr scaler; + hr = pWIC->CreateBitmapScaler(scaler.GetAddressOf()); + if (FAILED(hr)) + return hr; + + hr = scaler->Initialize(frame, twidth, theight, WICBitmapInterpolationModeFant); + if (FAILED(hr)) + return hr; + + WICPixelFormatGUID pfScaler; + hr = scaler->GetPixelFormat(&pfScaler); + if (FAILED(hr)) + return hr; + + if (memcmp(&convertGUID, &pfScaler, sizeof(GUID)) == 0) + { + // No format conversion needed + hr = scaler->CopyPixels(nullptr, static_cast(rowPitch), static_cast(imageSize), temp.get()); + if (FAILED(hr)) + return hr; + } + else + { + ComPtr FC; + hr = pWIC->CreateFormatConverter(FC.GetAddressOf()); + if (FAILED(hr)) + return hr; + + BOOL canConvert = FALSE; + hr = FC->CanConvert(pfScaler, convertGUID, &canConvert); + if (FAILED(hr) || !canConvert) + { + return E_UNEXPECTED; + } + + hr = FC->Initialize(scaler.Get(), convertGUID, WICBitmapDitherTypeErrorDiffusion, nullptr, 0, WICBitmapPaletteTypeMedianCut); + if (FAILED(hr)) + return hr; + + hr = FC->CopyPixels(nullptr, static_cast(rowPitch), static_cast(imageSize), temp.get()); + if (FAILED(hr)) + return hr; + } + } + else + { + // Format conversion but no resize + auto pWIC = GetWIC(); + if (!pWIC) + return E_NOINTERFACE; + + ComPtr FC; + hr = pWIC->CreateFormatConverter(FC.GetAddressOf()); + if (FAILED(hr)) + return hr; + + BOOL canConvert = FALSE; + hr = FC->CanConvert(pixelFormat, convertGUID, &canConvert); + if (FAILED(hr) || !canConvert) + { + return E_UNEXPECTED; + } + + hr = FC->Initialize(frame, convertGUID, WICBitmapDitherTypeErrorDiffusion, nullptr, 0, WICBitmapPaletteTypeMedianCut); + if (FAILED(hr)) + return hr; + + hr = FC->CopyPixels(nullptr, static_cast(rowPitch), static_cast(imageSize), temp.get()); + if (FAILED(hr)) + return hr; + } + + // See if format is supported for auto-gen mipmaps (varies by feature level) + bool autogen = false; + if (d3dContext && textureView) // Must have context and shader-view to auto generate mipmaps + { + UINT fmtSupport = 0; + hr = d3dDevice->CheckFormatSupport(format, &fmtSupport); + if (SUCCEEDED(hr) && (fmtSupport & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN)) + { + autogen = true; + } + } + + // Create texture + D3D11_TEXTURE2D_DESC desc = {}; + desc.Width = twidth; + desc.Height = theight; + desc.MipLevels = (autogen) ? 0u : 1u; + desc.ArraySize = 1; + desc.Format = format; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = usage; + desc.CPUAccessFlags = cpuAccessFlags; + + if (autogen) + { + desc.BindFlags = bindFlags | D3D11_BIND_RENDER_TARGET; + desc.MiscFlags = miscFlags | D3D11_RESOURCE_MISC_GENERATE_MIPS; + } + else + { + desc.BindFlags = bindFlags; + desc.MiscFlags = miscFlags; + } + + D3D11_SUBRESOURCE_DATA initData; + initData.pSysMem = temp.get(); + initData.SysMemPitch = static_cast(rowPitch); + initData.SysMemSlicePitch = static_cast(imageSize); + + ID3D11Texture2D* tex = nullptr; + hr = d3dDevice->CreateTexture2D(&desc, (autogen) ? nullptr : &initData, &tex); + if (SUCCEEDED(hr) && tex) + { + if (textureView) + { + D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc = {}; + SRVDesc.Format = desc.Format; + + SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + SRVDesc.Texture2D.MipLevels = (autogen) ? unsigned(-1) : 1u; + + hr = d3dDevice->CreateShaderResourceView(tex, &SRVDesc, textureView); + if (FAILED(hr)) + { + tex->Release(); + return hr; + } + + if (autogen) + { + assert(d3dContext != nullptr); + d3dContext->UpdateSubresource(tex, 0, nullptr, temp.get(), static_cast(rowPitch), static_cast(imageSize)); + d3dContext->GenerateMips(*textureView); + } + } + + if (texture) + { + *texture = tex; + } + else + { + SetDebugObjectName(tex, "WICTextureLoader"); + tex->Release(); + } + } + + return hr; + } + + + //-------------------------------------------------------------------------------------- + void SetDebugTextureInfo( + _In_z_ const wchar_t* fileName, + _In_opt_ ID3D11Resource** texture, + _In_opt_ ID3D11ShaderResourceView** textureView) noexcept + { +#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) ) + if (texture || textureView) + { + CHAR strFileA[MAX_PATH]; + const int result = WideCharToMultiByte(CP_UTF8, + WC_NO_BEST_FIT_CHARS, + fileName, + -1, + strFileA, + MAX_PATH, + nullptr, + nullptr + ); + if (result > 0) + { + if (texture && *texture) + { + (*texture)->SetPrivateData(WKPDID_D3DDebugObjectName, + static_cast(result), + strFileA + ); + } + + if (textureView && *textureView) + { + (*textureView)->SetPrivateData(WKPDID_D3DDebugObjectName, + static_cast(result), + strFileA + ); + } + } + } +#else + UNREFERENCED_PARAMETER(fileName); + UNREFERENCED_PARAMETER(texture); + UNREFERENCED_PARAMETER(textureView); +#endif + } +} // anonymous namespace + +//-------------------------------------------------------------------------------------- +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromMemory( + ID3D11Device* d3dDevice, + const uint8_t* wicData, + size_t wicDataSize, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView, + size_t maxsize) noexcept +{ + return CreateWICTextureFromMemoryEx(d3dDevice, nullptr, + wicData, wicDataSize, + maxsize, + D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, + WIC_LOADER_DEFAULT, + texture, textureView); +} + +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromMemory( + ID3D11Device* d3dDevice, + ID3D11DeviceContext* d3dContext, + const uint8_t* wicData, + size_t wicDataSize, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView, + size_t maxsize) noexcept +{ + return CreateWICTextureFromMemoryEx(d3dDevice, d3dContext, + wicData, wicDataSize, + maxsize, + D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, + WIC_LOADER_DEFAULT, + texture, textureView); +} + +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromMemoryEx( + ID3D11Device* d3dDevice, + const uint8_t* wicData, + size_t wicDataSize, + size_t maxsize, + D3D11_USAGE usage, + unsigned int bindFlags, + unsigned int cpuAccessFlags, + unsigned int miscFlags, + WIC_LOADER_FLAGS loadFlags, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView) noexcept +{ + return CreateWICTextureFromMemoryEx(d3dDevice, nullptr, + wicData, wicDataSize, + maxsize, + usage, bindFlags, cpuAccessFlags, miscFlags, + loadFlags, + texture, textureView); +} + +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromMemoryEx( + ID3D11Device* d3dDevice, + ID3D11DeviceContext* d3dContext, + const uint8_t* wicData, + size_t wicDataSize, + size_t maxsize, + D3D11_USAGE usage, + unsigned int bindFlags, + unsigned int cpuAccessFlags, + unsigned int miscFlags, + WIC_LOADER_FLAGS loadFlags, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView) noexcept +{ + if (texture) + { + *texture = nullptr; + } + if (textureView) + { + *textureView = nullptr; + } + + if (!d3dDevice || !wicData || (!texture && !textureView)) + { + return E_INVALIDARG; + } + + if (textureView && !(bindFlags & D3D11_BIND_SHADER_RESOURCE)) + { + return E_INVALIDARG; + } + + if (!wicDataSize) + return E_FAIL; + + if (wicDataSize > UINT32_MAX) + return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE); + + auto pWIC = GetWIC(); + if (!pWIC) + return E_NOINTERFACE; + + // Create input stream for memory + ComPtr stream; + HRESULT hr = pWIC->CreateStream(stream.GetAddressOf()); + if (FAILED(hr)) + return hr; + + hr = stream->InitializeFromMemory(const_cast(wicData), static_cast(wicDataSize)); + if (FAILED(hr)) + return hr; + + // Initialize WIC + ComPtr decoder; + hr = pWIC->CreateDecoderFromStream(stream.Get(), nullptr, WICDecodeMetadataCacheOnDemand, decoder.GetAddressOf()); + if (FAILED(hr)) + return hr; + + ComPtr frame; + hr = decoder->GetFrame(0, frame.GetAddressOf()); + if (FAILED(hr)) + return hr; + + hr = CreateTextureFromWIC(d3dDevice, d3dContext, + frame.Get(), + maxsize, + usage, bindFlags, cpuAccessFlags, miscFlags, + loadFlags, + texture, textureView); + if (FAILED(hr)) + return hr; + + if (texture && *texture) + { + SetDebugObjectName(*texture, "WICTextureLoader"); + } + + if (textureView && *textureView) + { + SetDebugObjectName(*textureView, "WICTextureLoader"); + } + + return hr; +} + +//-------------------------------------------------------------------------------------- +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromFile( + ID3D11Device* d3dDevice, + const wchar_t* fileName, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView, + size_t maxsize) noexcept +{ + return CreateWICTextureFromFileEx(d3dDevice, nullptr, + fileName, maxsize, + D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, + WIC_LOADER_DEFAULT, + texture, textureView); +} + +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromFile( + ID3D11Device* d3dDevice, + ID3D11DeviceContext* d3dContext, + const wchar_t* fileName, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView, + size_t maxsize) noexcept +{ + return CreateWICTextureFromFileEx(d3dDevice, d3dContext, + fileName, + maxsize, + D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, + WIC_LOADER_DEFAULT, + texture, textureView); +} + +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromFileEx( + ID3D11Device* d3dDevice, + const wchar_t* fileName, + size_t maxsize, + D3D11_USAGE usage, + unsigned int bindFlags, + unsigned int cpuAccessFlags, + unsigned int miscFlags, + WIC_LOADER_FLAGS loadFlags, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView) noexcept +{ + return CreateWICTextureFromFileEx(d3dDevice, nullptr, + fileName, + maxsize, + usage, bindFlags, cpuAccessFlags, miscFlags, + loadFlags, + texture, textureView); +} + +_Use_decl_annotations_ +HRESULT DirectX::CreateWICTextureFromFileEx( + ID3D11Device* d3dDevice, + ID3D11DeviceContext* d3dContext, + const wchar_t* fileName, + size_t maxsize, + D3D11_USAGE usage, + unsigned int bindFlags, + unsigned int cpuAccessFlags, + unsigned int miscFlags, + WIC_LOADER_FLAGS loadFlags, + ID3D11Resource** texture, + ID3D11ShaderResourceView** textureView) noexcept +{ + if (texture) + { + *texture = nullptr; + } + if (textureView) + { + *textureView = nullptr; + } + + if (!d3dDevice || !fileName || (!texture && !textureView)) + { + return E_INVALIDARG; + } + + if (textureView && !(bindFlags & D3D11_BIND_SHADER_RESOURCE)) + { + return E_INVALIDARG; + } + + auto pWIC = GetWIC(); + if (!pWIC) + return E_NOINTERFACE; + + // Initialize WIC + ComPtr decoder; + HRESULT hr = pWIC->CreateDecoderFromFilename(fileName, + nullptr, + GENERIC_READ, + WICDecodeMetadataCacheOnDemand, + decoder.GetAddressOf()); + if (FAILED(hr)) + return hr; + + ComPtr frame; + hr = decoder->GetFrame(0, frame.GetAddressOf()); + if (FAILED(hr)) + return hr; + + hr = CreateTextureFromWIC(d3dDevice, d3dContext, + frame.Get(), + maxsize, + usage, bindFlags, cpuAccessFlags, miscFlags, + loadFlags, + texture, textureView); + + if (SUCCEEDED(hr)) + { + SetDebugTextureInfo(fileName, texture, textureView); + } + + return hr; +} \ No newline at end of file diff --git a/GDP/D3D11/WICTextureLoader11.h b/GDP/D3D11/WICTextureLoader11.h new file mode 100644 index 0000000..d3e58ab --- /dev/null +++ b/GDP/D3D11/WICTextureLoader11.h @@ -0,0 +1,148 @@ +//-------------------------------------------------------------------------------------- +// File: WICTextureLoader11.h +// +// Function for loading a WIC image and creating a Direct3D runtime texture for it +// (auto-generating mipmaps if possible) +// +// Note: Assumes application has already called CoInitializeEx +// +// Warning: CreateWICTexture* functions are not thread-safe if given a d3dContext instance for +// auto-gen mipmap support. +// +// Note these functions are useful for images created as simple 2D textures. For +// more complex resources, DDSTextureLoader is an excellent light-weight runtime loader. +// For a full-featured DDS file reader, writer, and texture processing pipeline see +// the 'Texconv' sample and the 'DirectXTex' library. +// +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// http://go.microsoft.com/fwlink/?LinkId=248926 +// http://go.microsoft.com/fwlink/?LinkId=248929 +//-------------------------------------------------------------------------------------- + +#pragma once + +#include + +#pragma comment(lib,"dxguid.lib") +#pragma comment(lib,"windowscodecs.lib") + +#include +#include + +namespace DirectX +{ +#ifndef WIC_LOADER_FLAGS_DEFINED +#define WIC_LOADER_FLAGS_DEFINED + enum WIC_LOADER_FLAGS : uint32_t + { + WIC_LOADER_DEFAULT = 0, + WIC_LOADER_FORCE_SRGB = 0x1, + WIC_LOADER_IGNORE_SRGB = 0x2, + WIC_LOADER_SRGB_DEFAULT = 0x4, + WIC_LOADER_FIT_POW2 = 0x20, + WIC_LOADER_MAKE_SQUARE = 0x40, + WIC_LOADER_FORCE_RGBA32 = 0x80, + }; + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec" +#endif + + DEFINE_ENUM_FLAG_OPERATORS(WIC_LOADER_FLAGS) + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +#endif + + // Standard version + HRESULT CreateWICTextureFromMemory( + _In_ ID3D11Device* d3dDevice, + _In_reads_bytes_(wicDataSize) const uint8_t* wicData, + _In_ size_t wicDataSize, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView, + _In_ size_t maxsize = 0) noexcept; + + HRESULT CreateWICTextureFromFile( + _In_ ID3D11Device* d3dDevice, + _In_z_ const wchar_t* szFileName, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView, + _In_ size_t maxsize = 0) noexcept; + + // Standard version with optional auto-gen mipmap support + HRESULT CreateWICTextureFromMemory( + _In_ ID3D11Device* d3dDevice, + _In_opt_ ID3D11DeviceContext* d3dContext, + _In_reads_bytes_(wicDataSize) const uint8_t* wicData, + _In_ size_t wicDataSize, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView, + _In_ size_t maxsize = 0) noexcept; + + HRESULT CreateWICTextureFromFile( + _In_ ID3D11Device* d3dDevice, + _In_opt_ ID3D11DeviceContext* d3dContext, + _In_z_ const wchar_t* szFileName, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView, + _In_ size_t maxsize = 0) noexcept; + + // Extended version + HRESULT CreateWICTextureFromMemoryEx( + _In_ ID3D11Device* d3dDevice, + _In_reads_bytes_(wicDataSize) const uint8_t* wicData, + _In_ size_t wicDataSize, + _In_ size_t maxsize, + _In_ D3D11_USAGE usage, + _In_ unsigned int bindFlags, + _In_ unsigned int cpuAccessFlags, + _In_ unsigned int miscFlags, + _In_ WIC_LOADER_FLAGS loadFlags, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept; + + HRESULT CreateWICTextureFromFileEx( + _In_ ID3D11Device* d3dDevice, + _In_z_ const wchar_t* szFileName, + _In_ size_t maxsize, + _In_ D3D11_USAGE usage, + _In_ unsigned int bindFlags, + _In_ unsigned int cpuAccessFlags, + _In_ unsigned int miscFlags, + _In_ WIC_LOADER_FLAGS loadFlags, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept; + + // Extended version with optional auto-gen mipmap support + HRESULT CreateWICTextureFromMemoryEx( + _In_ ID3D11Device* d3dDevice, + _In_opt_ ID3D11DeviceContext* d3dContext, + _In_reads_bytes_(wicDataSize) const uint8_t* wicData, + _In_ size_t wicDataSize, + _In_ size_t maxsize, + _In_ D3D11_USAGE usage, + _In_ unsigned int bindFlags, + _In_ unsigned int cpuAccessFlags, + _In_ unsigned int miscFlags, + _In_ WIC_LOADER_FLAGS loadFlags, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept; + + HRESULT CreateWICTextureFromFileEx( + _In_ ID3D11Device* d3dDevice, + _In_opt_ ID3D11DeviceContext* d3dContext, + _In_z_ const wchar_t* szFileName, + _In_ size_t maxsize, + _In_ D3D11_USAGE usage, + _In_ unsigned int bindFlags, + _In_ unsigned int cpuAccessFlags, + _In_ unsigned int miscFlags, + _In_ WIC_LOADER_FLAGS loadFlags, + _Outptr_opt_ ID3D11Resource** texture, + _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept; +} \ No newline at end of file diff --git a/GDP/D3D11/Window.cpp b/GDP/D3D11/Window.cpp new file mode 100644 index 0000000..123047e --- /dev/null +++ b/GDP/D3D11/Window.cpp @@ -0,0 +1,99 @@ +#include "Window.h" + +INT Window::init(HINSTANCE hInstance, UINT width, UINT height) +{ + // 1. describe window class + WNDCLASS wc = {}; + wc.hInstance = hInstance; // application instance + wc.lpszClassName = TEXT("D3D11"); // name of window class + wc.lpfnWndProc = WindowProc; // message queue handler function + wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // behaviour style and not visual style + wc.hbrBackground = CreateSolidBrush(RGB(255,0,0)); // set window background color + wc.hCursor = LoadCursor(nullptr, IDC_ARROW); // set window cursor + wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION); // set window icon + + // 2. register window class + if (!RegisterClass(&wc)) return 10; + + // 3. adjust window size (optional) + DWORD style = WS_POPUP; + RECT rect = { 100, 100, width + 100, height + 100 }; // left-top corner, right-bottom corner + AdjustWindowRect(&rect, style, FALSE); + + // 4. create window instance + _hWnd = CreateWindow( + wc.lpszClassName, // name of window class + wc.lpszClassName, // window title + style, // visual window style + rect.left, rect.top, // window position + rect.right - rect.left, rect.bottom - rect.top, // window size + nullptr, // parent window handle + nullptr, // menu instance handle + hInstance, // application instance + nullptr // optional parameter + ); + + if (_hWnd == nullptr) return 12; + + // 5. show window + ShowWindow(_hWnd, SW_SHOW); + SetFocus(_hWnd); + + return 0; +} + +BOOL Window::run() +{ + // 6. run window + + // message queue + // GetMessage - event based message method, return something if a new a message occur + // PeekMessage - returns a boolean, to signale if a message is available or not + // TranslateMessage - translate hardware keyboard codes (scan code) into virtual key table + // DispatchMessage - send message to WindowProc + // https://learn.microsoft.com/en-us/windows/win32/winmsg/messages-and-message-queues + + MSG msg = {}; + + if (PeekMessage(&msg, nullptr, 0, UINT_MAX, PM_REMOVE)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + + Sleep(10); + + return msg.message != WM_QUIT; +} + +void Window::deInit() +{ +} + +LRESULT WindowProc( + HWND hWnd, // handle to window instance + UINT msg, // message id + WPARAM wParam, // main paramater + LPARAM lParam // additional parameters +) +{ + switch (msg) + { + case WM_CLOSE: + DestroyWindow(hWnd); + break; + + case WM_DESTROY: + PostQuitMessage(0); + break; + + case WM_KEYDOWN: + if (wParam == VK_ESCAPE) DestroyWindow(hWnd); + break; + + default: + return DefWindowProc(hWnd, msg, wParam, lParam); + } + + return 0; +} diff --git a/GDP/D3D11/Window.h b/GDP/D3D11/Window.h new file mode 100644 index 0000000..922a962 --- /dev/null +++ b/GDP/D3D11/Window.h @@ -0,0 +1,17 @@ +#pragma once +#include + +class Window +{ +public: + INT init(HINSTANCE hInstance, UINT width, UINT height); + BOOL run(); + void deInit(); + + HWND getWindowHandle() const { return _hWnd; } + +private: + HWND _hWnd = nullptr; // handle to window instance +}; + +LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); \ No newline at end of file diff --git a/GDP/D3D11/main.cpp b/GDP/D3D11/main.cpp new file mode 100644 index 0000000..831dd9a --- /dev/null +++ b/GDP/D3D11/main.cpp @@ -0,0 +1,105 @@ +#include +#include +#include "Window.h" +#include "Direct3D.h" +#include "Mesh.h" +#include "Material.h" +#include "Camera.h" +#include "Time.h" +#include "Light.h" +#include "Utilities.h" + +int WINAPI WinMain( + HINSTANCE hInstance, // handle to instance of application + HINSTANCE hPrevInstance, // deprecated + PSTR szCmdLine, // command line + int nCmdShow // how should the window be opened (minimized, maximized or normal) +) +{ + // some constant values + const UINT width = 640; + const UINT height = 480; + const BOOL isFullscreen = FALSE; + const BYTE red = 255; + const BYTE green = 255; + const BYTE blue = 255; + + UINT error = 0; // error code for identifying errors + + // 1. create window + Window window = {}; + error = window.init(hInstance, width, height); + CheckError(error); + + // 2. create connection to Direct3D + Direct3D d3d = {}; + error = d3d.init(window.getWindowHandle(), width, height, isFullscreen); + CheckError(error); + + // 3. create a mesh + Mesh mesh = {}; + error = mesh.init(d3d.getDevice()); + CheckError(error); + + // 4. create a camera + Camera camera = {}; + error = camera.init(width, height); + CheckError(error); + + // 5. create time + Time time = {}; + error = time.init(); + CheckError(error); + + // 6. create a material + Material material = {}; + error = material.init(d3d.getDevice(), TEXT("wall.jpg")); + CheckError(error); + + // 7. create light source + Light light = {}; + Light::LightBuffer lightData = {}; + lightData.LightVector = { 1.0f, -1.0f, 1.0f }; + lightData.DiffuseColor = { 1.0f, 1.0f, 1.0f, 1.0f }; + lightData.SpecularColor = { 1.0f, 0.0f, 1.0f, 1.0f }; + lightData.LightIntensity = 1.0f; + lightData.Phong = 8.0f; + lightData.CameraPosition = { 0.0f, 0.0f, -1.0f }; + error = light.init(d3d.getDevice(), lightData); + CheckError(error); + + // 8. run application + while (window.run()) + { + // 8.1. update objects + time.update(); + mesh.update(time.getDeltaTime()); + camera.update(time.getDeltaTime()); + light.update(time.getDeltaTime()); + + // 8.2. render objects + static std::default_random_engine e; + static std::uniform_int_distribution d(0, 255); + + //d3d.beginScene(d(e), d(e), d(e)); + d3d.beginScene(red, green, blue); + + light.render(d3d.getDeviceContext()); + material.setMatrixBuffer(d3d.getDeviceContext(), mesh.getWorldMatrix(), camera.getViewMatrix(), camera.getProjectionMatrix()); + material.render(d3d.getDeviceContext()); + mesh.render(d3d.getDeviceContext()); + + d3d.endScene(); + } + + // 9. tidy up + light.deInit(); + time.deInit(); + camera.deInit(); + material.deInit(); + mesh.deInit(); + d3d.deInit(); + window.deInit(); + + return 0; +} \ No newline at end of file diff --git a/GDP/D3D11/wall.jpg b/GDP/D3D11/wall.jpg new file mode 100644 index 0000000..088fa60 Binary files /dev/null and b/GDP/D3D11/wall.jpg differ diff --git a/GDP/GDP.sln b/GDP/GDP.sln index dda1ba4..29615c7 100644 --- a/GDP/GDP.sln +++ b/GDP/GDP.sln @@ -5,6 +5,8 @@ VisualStudioVersion = 17.14.36414.22 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "D3D9", "D3D9\D3D9.vcxproj", "{C9AF8C4C-4A28-426D-9B68-BCEF1B1E4845}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "D3D11", "D3D11\D3D11.vcxproj", "{C46808CF-936B-4F98-81C2-1E10D9F1822F}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|ARM64 = Debug|ARM64 @@ -27,6 +29,18 @@ Global {C9AF8C4C-4A28-426D-9B68-BCEF1B1E4845}.Release|x64.Build.0 = Release|x64 {C9AF8C4C-4A28-426D-9B68-BCEF1B1E4845}.Release|x86.ActiveCfg = Release|Win32 {C9AF8C4C-4A28-426D-9B68-BCEF1B1E4845}.Release|x86.Build.0 = Release|Win32 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Debug|ARM64.ActiveCfg = Debug|ARM64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Debug|ARM64.Build.0 = Debug|ARM64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Debug|x64.ActiveCfg = Debug|x64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Debug|x64.Build.0 = Debug|x64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Debug|x86.ActiveCfg = Debug|Win32 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Debug|x86.Build.0 = Debug|Win32 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Release|ARM64.ActiveCfg = Release|ARM64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Release|ARM64.Build.0 = Release|ARM64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Release|x64.ActiveCfg = Release|x64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Release|x64.Build.0 = Release|x64 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Release|x86.ActiveCfg = Release|Win32 + {C46808CF-936B-4F98-81C2-1E10D9F1822F}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE