From bff01f5adbf356170767d9c8407ffec1e6dcc50f Mon Sep 17 00:00:00 2001 From: David Hackbarth Date: Wed, 19 Nov 2025 09:43:09 +0100 Subject: [PATCH] add D3D11 project --- GDP/D3D11/Camera.cpp | 28 + GDP/D3D11/Camera.h | 22 + GDP/D3D11/ColorPixelShader.cso | Bin 0 -> 14736 bytes GDP/D3D11/ColorPixelShader.hlsl | 18 + GDP/D3D11/ColorVertexShader.cso | Bin 0 -> 15484 bytes GDP/D3D11/ColorVertexShader.hlsl | 26 + GDP/D3D11/D3D11.vcxproj | 297 ++++++++ GDP/D3D11/D3D11.vcxproj.filters | 101 +++ GDP/D3D11/Direct3D.cpp | 94 +++ GDP/D3D11/Direct3D.h | 23 + GDP/D3D11/Light.cpp | 33 + GDP/D3D11/Light.h | 28 + GDP/D3D11/LightingPixelShader.cso | Bin 0 -> 22564 bytes GDP/D3D11/LightingPixelShader.hlsl | 45 ++ GDP/D3D11/LightingVertexShader.cso | Bin 0 -> 16452 bytes GDP/D3D11/LightingVertexShader.hlsl | 33 + GDP/D3D11/Material.cpp | 194 +++++ GDP/D3D11/Material.h | 40 + GDP/D3D11/Mesh.cpp | 129 ++++ GDP/D3D11/Mesh.h | 30 + GDP/D3D11/TexturePixelShader.cso | Bin 0 -> 12864 bytes GDP/D3D11/TexturePixelShader.hlsl | 13 + GDP/D3D11/TextureVertexShader.cso | Bin 0 -> 15660 bytes GDP/D3D11/TextureVertexShader.hlsl | 27 + GDP/D3D11/Time.cpp | 34 + GDP/D3D11/Time.h | 24 + GDP/D3D11/Utilities.cpp | 14 + GDP/D3D11/Utilities.h | 27 + GDP/D3D11/Vertex.h | 20 + GDP/D3D11/WICTextureLoader11.cpp | 1096 +++++++++++++++++++++++++++ GDP/D3D11/WICTextureLoader11.h | 148 ++++ GDP/D3D11/Window.cpp | 99 +++ GDP/D3D11/Window.h | 17 + GDP/D3D11/main.cpp | 105 +++ GDP/D3D11/wall.jpg | Bin 0 -> 217711 bytes GDP/GDP.sln | 14 + 36 files changed, 2779 insertions(+) create mode 100644 GDP/D3D11/Camera.cpp create mode 100644 GDP/D3D11/Camera.h create mode 100644 GDP/D3D11/ColorPixelShader.cso create mode 100644 GDP/D3D11/ColorPixelShader.hlsl create mode 100644 GDP/D3D11/ColorVertexShader.cso create mode 100644 GDP/D3D11/ColorVertexShader.hlsl create mode 100644 GDP/D3D11/D3D11.vcxproj create mode 100644 GDP/D3D11/D3D11.vcxproj.filters create mode 100644 GDP/D3D11/Direct3D.cpp create mode 100644 GDP/D3D11/Direct3D.h create mode 100644 GDP/D3D11/Light.cpp create mode 100644 GDP/D3D11/Light.h create mode 100644 GDP/D3D11/LightingPixelShader.cso create mode 100644 GDP/D3D11/LightingPixelShader.hlsl create mode 100644 GDP/D3D11/LightingVertexShader.cso create mode 100644 GDP/D3D11/LightingVertexShader.hlsl create mode 100644 GDP/D3D11/Material.cpp create mode 100644 GDP/D3D11/Material.h create mode 100644 GDP/D3D11/Mesh.cpp create mode 100644 GDP/D3D11/Mesh.h create mode 100644 GDP/D3D11/TexturePixelShader.cso create mode 100644 GDP/D3D11/TexturePixelShader.hlsl create mode 100644 GDP/D3D11/TextureVertexShader.cso create mode 100644 GDP/D3D11/TextureVertexShader.hlsl create mode 100644 GDP/D3D11/Time.cpp create mode 100644 GDP/D3D11/Time.h create mode 100644 GDP/D3D11/Utilities.cpp create mode 100644 GDP/D3D11/Utilities.h create mode 100644 GDP/D3D11/Vertex.h create mode 100644 GDP/D3D11/WICTextureLoader11.cpp create mode 100644 GDP/D3D11/WICTextureLoader11.h create mode 100644 GDP/D3D11/Window.cpp create mode 100644 GDP/D3D11/Window.h create mode 100644 GDP/D3D11/main.cpp create mode 100644 GDP/D3D11/wall.jpg 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 0000000000000000000000000000000000000000..662cbf2833beb26df8e33e55458683c890731540 GIT binary patch literal 14736 zcmeHOU1(HC6h6C2Y<|rqCK`>^!D<_Sy1Oy4)%b%+*2G{mX*L#Z7t(celPp5CLeDy2_uzwiE->k?A~2~l%T zIQPt)nK?6a=H9bs&P+nbT3UZne+`s>a_Ga7^tIaYO*cC{B65D0$P=J@fd7KA(<`!n zr^q+JLX<^-&8g(B&rn7bZ#H`#bR&}Hlc{O+p!`nun1ou6w%4Jgk!=7ZBfvah28eE? z6wI@rtxb`mX-!W@hN7|I(~)#)RF7#9T^mV(bxPkJ+}_Z4BGMk}j)WRQ_4Sd~R3fE! z$H%oqcqrPh>HeWaIw2P?vOke*b_jBdk;;H_ZWEvLrUa1kpes2w$3cyhrx%tLoFHe@MJf633C zzkv!!KY>7nkS+tV%!S8W1N7TmSh^Z`-(T;!J^o~ze&gz!$IriWx#-Zx;qi|?)&8_i zg5guL+zHoTXvk$bi{11iq5-8;ATW?fMKg`c*e9vI%Ggf%joj|CV$?ttBj?vq8uSMT zc7vmmDWz-uDmD~NCbfiF(XOs*nNdAyN`#CzjQtv4n0Da79NnBlJ|Czh(vE!}Ijl`! zOSW>Y6}2&+aOEYDt{?K`4{TD`edm?tjUI`<4Sk#2$NB8amGuy6Af3@iV;N;cT{@B@ zqnWbe*UXRDG75H7MK!7Li+$Z);f~&pt|OLRxW{lbsn)K}t{#5wz_MbikP(`?Y5Asg z*=&mIZSHA5&}(#A6bM*G!)#Yq4?D9>+{tiwcGNSx(-O$@ppgz;u;EAHq&oE*e)!h2IytA$es$Hv4F)`Cx7K_&8E}Q z;n}0sBKu@-g@^I_wnTI=Ey3{}!d!1uAJj53lJ0Bl3-%?nF)h)ztFOT*JCMxir_BJq z$QJQcP!0R}G68B#V$cHkA_{qrTrk4@e%V*y1+T~o{99G;OIAvEg~y0y=@2`ZnWE3KZu$6Bd<5D{oQsy6PVM2jy%_u&J4I zpL5kf$@ldhV?FSGEd%o0su)o~>NT4+_gh?BBEJCzB&?L$>iwXs=M&Slk-w)VpO(DJ zvTC&B2QYmkH)->HV*J|61}UgEem9JItV`L`ZX#vD3RUu*;M zCTZIXVUTHWiSq$!K7_b3Tn)GySTGG#$|hsqbp}0n?9G_fn{68wtaDfJqHAC__t{7HefH%hLuRHwlfyB{RQqLRgSOdMU*CF z#dKarxn0+4YFeCRDv3Lb^6c0CNxOVzSzhBDky1Er%3wYEEd-lK%6+2U+dPG}#g3I5 zW3&fqcg#++*-~Q=W|}1rJ>-CLn>oQM~fY>%S}`@Osh)AYE62dnLit!n_mPW$TqrIW7pMeS3gjY|1KBSZ zbp@~z=)&S?fcD%4R|BpFTn)Gya5dm+U}8_6K&0lY-sZzzr_41 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..a2c1f04e323e26bd8c9d47e6fd563c1f7d3e3fdb GIT binary patch literal 15484 zcmeHOU2I%O6+U-&ova-@{=s%bW74anz$OjrbsQjdoytEO$3{-bf~ZhILNXPg3My2UJfu<)2vsO=#U>ygDlgwRcV@kH z*Dj$>Y3zHfvuDnkGv}T;Gk5O%IsCP*?xR-+-uT%I{ckos^~Ybm>O1l+OGKV&7ugF6 zA{V{jeIn1cfq6vaCNO}E&Q$W@Cgc&tvzEW*5jlyZB@f~^r13%UOpExCGGIY}E&qaq zyN1sOAoQawff}>GN?;a9)2~B#1GKwsWH=K`XGW&S#xFlPl1b&#Duj$2%QKE;vIng*FdU`*rH%S11;{I4{PKBAacDwCJ@{oA zqp=5RV{@Y|_5qXUN16`Nj|!cpjeSUyQqFdI3s?h3>4&ZTKLy$Wr2RoHqwe!a)2|Cc)(#9EwR`&`{kGF?c6VxKHlB#3?UqomMIL}@*jW&%zUHK@1qVao^ z8vZc0wRmmn#L?+Fq^Y)zY?Xg_lYH7?`L0d!js0(LlFxqiB{b(M@@b3DCsi_A`?BAm zMyB*2BYhMdDKZ%DVuAH`?{4mX=pp-Dq{sepFchk)xIY|$E~8I>4g#Mi4>;fu_jd0`heFo&lM;a<8x}WAXBtiz#M9`Bufz7@ydzAcK!bL>mmbx@X9}rh#Y#=Be6F< z@+ZGnj)0%~ktJ^(^GL(r@HA&Rxm}NS?R-KaFn%dFIf>03=S}ZYOjX6x&I>=IUjNMp z2EO0Gs)|fDog2^E&VFBCayFMO*qBVD#wN0i<8NDcI;o>RyN;nqs&91wl(zr=#A~no2ARw+{*F`6h5vs9ILGRe z_FA49h*g1h3fA3@8M?kZy!EL7_mof9T0G+ENsLWpBsBj;Ar~D>PsOq_ml-`d8X8T+ z=3({xipZ3Rp`NNgQL(8Xr|MZI@tB~IW5-j}jjElfN_c|~NY!q40RKkaq}m ztuBfGf(^C}!S4|CQy1<=1or)|#X3d9=sXobws8e^ff@gN-WiMoNE6u>At0eq4mNav zQm;mwIlTO1b>(y7t*dH4Id;bNh$pn+or---R=ui=<^AJSgXL()|6*YO#KJGA5TCsF4E4SRK2ru{07?zzLE zxc!|r6WO<+{daf>c6Ie|TZh*q3g3`Y!LUUxmXf=&dp`m^@4LUec?H9rRARK_cuQ>1 z6yzg={gEwvj0RYF7d{XHu5(=2c@e0S&#HCzbEul77vn*BthO8j0_S_qjevZ9)59U9 z%&)i>U zT__{v8qhp#yN)%?S&8z|IBFiqhvxH@>fuhBIiGmg>i$O--Z%Hhlb8FFlPPIVj?Kg} z(ws?;H&4fSrT06TyNp3#X8P}cK%n%{h1V`<5YnGMg24g9yaA^IX`&-bDbpToGC`4sJ# v*i>VZ)JcH`%IP=d<_?>vyKu5J0DFwjMtjsR*h4xDG*GYyLD981V{+*~5E#gv literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..041c50feb786ff1dfffb51a6c2654d065d1cb16c GIT binary patch literal 22564 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 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..8801e79e7561a378d1a630026f5b98b21f605314 GIT binary patch literal 16452 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 C$%?oD literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..fa02e734ffc6f88e098e0867a3175b3899cdbf12 GIT binary patch literal 12864 zcmeHNYiv|S6h3#iE!(9F+uA|}A6J4{9&WcSM5suh-4<#JE#0j_Ty3}Qg*I$=H~Xl? zR~j`DqcO%b@evaFp@~UjB!(YqG!lPkVocP3V)&&-|CkUE@s+TC-@SL>rfCr)M%&)A z`R>e|GjnF<%-wmMxsiP>t#7ZmP`>DvlW*?5!`L5v>7xowM7B4IEJC;y&^;p00+V5p zV1vjBpaSw8>C~3f$V`Z*SUiES4pHmLSeMP(P9% zNvF^@FHizlR2Y*fi|4t-dljNLfOmlRfl@$|GQcCBAx#gb0%t+G6>J8yggWPNt znGo?Fx8u)?Z|SiXFhrJu|J`x%eRm8hJ>WAvQ7no?cSU-JP}g?gdSE~E_XiOZ*;k8h zWvqB_ugE}9yp6#idLv>W-#OiqwTYCgc)Klcf6S68UE5%UXm_MVLe4(5*0-)-ukVhw z>vx30;edZdB+81>dG>!f@FdfqWme!m=Ya)I@{i)ug0;YA!PMi@g0%qGPaWXigG56x zECVQWX?|P4+6T?=KDxb|-2#)L2JPqZ8%Ma0{Oqair@r{(x5$gn^tZnL!|xBMQj`%+ zI=#1PI?E|`<8#CUILYzYAv|}?M!HD{zYI zZ9QK3>JzV=TIZ3P??qmj@<>OuCNF=06~jJG&h4JNt)~TSA5LRL-wlt9ow_sNk0wSl zaA-vHiM(NoYz9ODe=eUb4CZyy@zasY6!HQ8!vVhzI*?2!@*8#K($Sms=skViUD1wM zN7o*dy_Ba>FN{GNYune_)zuS$=uuO(t$^;Ky36`?(^It8QWx9Nv$HLBsmiPYCsfMW z{E*ewI`+tJ_6AEss4%vcRk>rYEO7D6#WP&UpXTFQIRIs_IbQf{PvXI$Onj(m2%f~e z)^OrJA#k3amBalw|U?jY&X|HJ}(m0DzLWzZZzKgKXrb>2|n)q1=|w#i+U8omGR z$;82&gvU1tQ?W$$pplnMu5V*sxG!mp8OgpaeNCpUEtSt6wk`rh)=99ECJFLo0`dJJ zF)YJ=gZ>Fkj&WUp+j?827rb)&0)hFiM9ZYRQZv07CAJ<*yW*F?wQlLJLyZ1yE5Fad z_c{0#4nFTSRQ{lY&n=STS3CIC;5VcFrO0qZwz5CEy@HJ;k_7|4`7082dS>Yh`7`x} z{F(Yf{`9_h;Q7HeP-+3b5wq zmkB#G4-ZWDTYS{I3G$6*$T;T*mL<`iB-&}C8FL^1rUe#%+MsP_1sK-=z_Itk3&`;( z7O~d{aU2N#2RNprWwNqnJ3{6QinVK#pU$0CeEyAn7Qd1FHR7!b)TpzA+8@eU@-);N z6x{Y9-zq7sVObA&ifZNZPLO#pJ5}-BeC9>R%B`tTDn-92KOm)y#1B+f0X&$J+)HW84u9jx`CkXV1UA6l_W`Cq0O@xT zpFl|e%rX4O)Y-od>CH&1xq)7SY9Ihy2P^@~0S*<1W--8hBZrSew-jK#Re-tqKv1mFe_b2HfteU&=YBEKkCTDdT(I5q*yG4Vzw&| zSYAj9E|aQv7%Z0KQov<{%P<17&75<1Zc*nF=NaZ|Z#FujJNI-$59{DurshW0uiC}= oECMJZ-;^Wbxc(M(*)3C3Q(e%@`IGsmR|gb1^`g9W-;F|l0$(84YybcN literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..8ff453aea036eb1cb26371c2572e7c32435d2879 GIT binary patch literal 15660 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 Qp`a5F-lEsviq+2j55U6^egFUf literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..088fa6086bfaf6e8b51bd7337c76805738996b8c GIT binary patch literal 217711 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 _X`l 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

St`1d+yr0aj-?Bypi(r+;I|ra>ru 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 }v(Evi&@ zzW2PedRc$KK25Rkr^TD=JInhI+JjfrB#!QDFDB>VSA$XEo&tCXEh7>~GmWIV7!AWG z-Wm5k6Zn;=Sj{EZ?LDkEqW22$!(s5F!6r*pgZ*sIWb=dq59&3b0HV!9WK zG^>3rucu4hNu<|UxS_xUL8jP)PKk_^a!~XyRJa?{m^!!S^{iXavF28f(s5~8U{{R;A!fU2q=(hJ} z_R2j%-6Mk9GYsX~WVT2rX&raU%ArTnddI;pijjDBY3_b8TWWSf7?w*LkB0sqiXS1F zB6%X3EA8?T6Bj7UBDr0p4CcF^h8i7)u5@J(CA2p4T&3l^x)qV_!|aryKRS>I!8qJ~ zdUu}^@4P*!rLTtLy10E)Mi_Lry89=P?%s4vZ4i-hvLzu)WC4c3!4>Ic_5Qg!^&Jc~ zN_c2foFyDR7&u#&H0iELd$6ZyyC#xO(LB6E<&+@~dU2Hb>LpgB`L89;+mqGLTc@LM znccR2eb4Y~;%=9x>Kcuw#ON&a3k$W>tm3!$Yo%R4;ax?;wXBz5TC$8bZHy{HlFHfV z+w||*MoeeFuZ3P?QbP4vY0N6p|D79NV zms|Z8Ns?WXXj;5QM)tM5xV2kp6oR(?a+2G!Ix0erBCIMp6uqq_q~lHse42Z)l2=}8 z=`>+c^72}xNWsZ3iQX?uw9~r3b*b}io$y=YMZT4HXL0*QM|EkU87=Q(kKu-ob0C2v zGK*A6^*Ka#>;}Q*1ZChW4$Rd)1^CNH(`iQ!xwYg z&oi-#Hpa;1lXQsy8)N%2{{RTUA+SHYjw{Nnr5VLk!C~a*E2gNy?5!6o#a?`>&H251 zbt>NPH7rGI>1FL_uF1P!*Vl8%yhGv_(;re)Sgp)iLN6{&+p!>kELry$N3_qJAG^B)F)1gVn9CLE$2@afCxNHdVbtZ1T#nO9iW#mZ^6gkjcdD5bguP+a6+ZsK zf!J|hKU%D6RjAb5lx=qJrk;MCKNH`>(4`7|sY{t8lTOyXyr1W8o}Q&?ZGC5TEO9@S zWLtkC)H#gA9CD!WQ5cdN1OlYw9&72{14y&K(=Bf%lGaOGTXDVzg%TTC6>}trfNXg) z(SQw~nDfniooA`d;tg8r`%alJZB?>x#Htw+<7%^O(m}Pv-7sC ze@NEVZd>eEx{}+n>DqRiEu@k?)P^z~`LSLtx-j1V04R*etG#0_^KAyXp8@I3;#gi? zX*BoKB!#5Y8qpr=_IF*(3z&pTS;xF4>EmehFWj4 z+(hv}k+yTN&haMP?Fd)_jOXYdhkA8~hx{jhtzDU|?WNSC)AauUA(bW~D8QVeV`>1% zKsUcez<&6s93D@u)MpG%WSf=g;i%4X=1r%~?xea$me)_uqZ5zSuuar_wI^1aO3h8i ztAtgh**LrOZSQ-YZKPX0oOfDIiJ?RGd#Uce+pNts$M%)LNt7`XNrCogQ0&?tDY;cJ zrK@DhQKPZ6w~iZUk7Ed*DdmC$kFj_S+@HLAlU{*!sOk3cNvH|cG|?2Xs;sfhi6p-{ zGOF_sZH?v;fyl_sdG(dVHy4R2JWi84`DWNJllF7T`LW9$<2dIyHOWz^%AX{Zy^H0& ztfbqsx_-CT{{Vof##O0V#!eD#H+$`8Z^0fX`%=qtzq1$Z4?VF_1&6}TX(76Ao6C=M zC?!=R=5;RHTLi8+>s!77jy1H?8qVGuxU}B}cw#iwF2YL?x;`J%-gb)8K*}T@V9O{3 zU}TI6qx(=5U)gu|k93;a9XfA@T9vGAa6ng)?<~Zz$DRRUh3rOq=Co5&()3RX_;TCr z)|w&y!O%$Ew8M-76Fy;bFB zf3+^|^_RsgW+&OjzFajFmYmnJh$4c~%3D{^l2Z6Pp6QYFPPo^DI%{&p@tT0_9E2nA& z#8)sZz@x^45xjdj6;o7ucJLSWqov3?Vy*0U_MTcarH<%ieZwmSzyPoZX;J|lYrs5N zs9oyXOX?ma@giEi{E%G5qr8g^v;zqQc2EdP#wGIMS9}e`N~&_Ipm;fMADT@xqbNpK zPAhe1d)oKcM|OLWy;!)}!PAsnuG7A^>22x0pxc)$sdo+g zyjqRH;^7R+#v=PuXj+5A*ZP&swx!}tR(C6*X{SW+%n>H<^{NZ1rz%WJ-@AMU8;Jx~ z$A#=64HebgBKmpsYulU4EkT;rN#5#dBDYy2Vimq!o>MkRQn(8Rr2Hjl2iZ*BN^kIa!qT9t&6WYQ{-!!oOzq~ zlW^syNvQNur|!FM_O*{c6^f#g)hQ{o``+G{-|=0}E*(jHDXqbG98-B>__R|4hBop- ze$boqyI_()O7tu;K|I#BnP;MFy6wiTeWcv2#kIs!CC#P7T|sdo^9*+p&RH9H`I$~Y zW+wwYcjLoR>PdBK_IBdl-rUPI#p4C@zSO(+TRG-4&H+qx1KN{G@T9sujA?Ny+v%38 zeRAsq2_?R`2pZlU{IfC*s-%)Z?_1H!vGe3rsk)SOZW}pi9#Uq_1wE0^0 zjX8a!^}4pV(e?dV!OefKYWjqYaU>F1Pa`gyrrH4{l3HAx#XbCU@ip23fh>TyQ^5kd z%|lA@Hld^?mZ0-n>3e*yvf|!2qqmEgiz?w!2>_B8IOTd)?4BLbt`^f$({JRHSp!cu zcC$jUK`2!ueV$dpU8AT%272{1gW|16UAxk*e#tAqw$rR~B0{btj1icfh$mwJRQ3zf zw1x&$D$b=!wsYm=`n^cX+?%QCdupt->R_w6a;k8ZIH#(q4pi@F?xw8z-rdo}>-INE zY!Pn_j7w}`!YQ6BrBopppe1EsKIZKD0u5kGYXV!^1&wC8v;sw)n{=GuC|LP0sbUFL z1A+B5e{{Nqgji*`zW)(zzaQ?!nqhV3h=5W9wVmO`eydYB1ev&OX$bxtC3g z65L))6^vHyhdWiq3yzovK9z^FlANaR$ld2On{bcXcI#z%HFbTCiPfB3Q(W>(+~u@d zc1p{&-%>vccxw9p09CNMy0?LKHJxRML?VjLSYrM2ME%>G8BtUg%SnAX~X90X}R2WC5zAy5-f)x_FlV z086;A(ymSXR*>o0&z)@Lnl^}HG-icadH|%7E5rP6_W1RPA3BO^cb4N)wz9gp63H03 zI9PnR$oZ#>h}432kb2^}VP05T601TJZc=eoXBP|7v|6+s-LK5=&DPc<*}Pp?#ZP>N$t5ee?`x#i-bc4uYg*Q?cd2OpAh@%&x>Ps1RrQ6>oo@}SQF%p{JD=X##~5O= zTC}n$5)2Ta=jHuZ!1^A8skexAi+OeU(rd}0GRY0B0!zko1fvpB`t6o8=H9_85X2V<}hr>y(4B_+epIKwJl4;HxHv< z-CM`0TPh{25X6SxPqc-CxD%r7XH}JeKYPALGhLZ>9cGoOx>0=e=BHjaa-SmQl%F!S zp=k4R?PS+moBKN0M`^e0Yb6-Xd#%dp$_n?jzpkg1c&_tEWYjGh%J)vw^;mE(+HoY7 zw}wSQdZI(QCrzhlj}IU_Ngx4UkD%N52T<_*R(dV^-)cEX?_SB-F0Pv1I6}>Ixy)@d z`J_NNMp+3THct!VUk={gX)i3%$8R>D6PrblE4|yqxq@iXvK^e|vPV)m=QZJ80lb&O znv-~!Q+ul@wHvSO*<(j&{OkLcWfN=%Y$gI1=D;o`InLVk{j~F3J}#XsOrsnwI;A=k zp%kFw1mfSjX(ZBfOPSg9(@vgBRPA>wq`!G4-L9hczim2eW8S_$MX5#M{{VsUXx8lo z+Wd9!$c^QO8QMc{rC+#(qMs$-XxxXKcIkno@n^(-EAZcfw0#>z)U^9;Z&}pD+LX7^ z!p0pb7AYrNsE}jk+R(uqnc8DOpbQG5@t0Pb-%S0U&aE^Pe1F;qK<)w^Q^UVgL={Z6?uPxR8^FZ8|+P>C@BD<8=KW zOoDlh(7A>v8Y^KJn(Q_NOsoWw76f9!k#K>-3~)*H>ky{SYfCd5TFDYbE_RP4;TYJh z!BZ-p0}xm@PHU9bw2PF{*52M&A=IImi))#oX_5Td3$#qBhAd-{bv;gNXG>dqD*>lH z(%Q(dK`z3wB1s`5dq*6ZW!&WOMnLb1@^LTPQ=?a-=YosY-pWcB(@k7%l3HAb+v_B^ zwX|31w@dtpA~M*^Dr%Fn>ACW)SzzC(z0^lyiLMAT$r_P`+~>EwbGpop_K|U_nAuY% z+Ds@IZUV{2`og$Z&pcq0Ua2~ymdhbjl1u_vpll%-5-B`_SLP&hoL8OeQt29uHx^L3 z-dx!OGuzt%B;Vd>-#I>G9!7b|{42}D)TryF7}lMn?y09MB>JTEy{x>AVI=gk(Jj}K z{=P`zG|g8_x79T%bnR~1;>r{dO{QC0tYM}&ZPt^_07o3;$B#~G-leMAYMQ2y(OaLh z%JLThKv|hVE4(ic^J5#bewE?+(6&0Ix@nQ!L2YpDc5NOZ=H*EYOJgB&556;9t-Z+b zwT*_k;$1@8Sg&p*mq|8Pu&uli0g^66x!S-3z`^=g-(^?@3ei|qC`z3wm8!|N8quc? zMJG6Xa95gEZK++~W1hT}A$s$Swf9#d*JSrkZ7rw#4&MILQ4X=^Q`!z2?O)|)e{{U(Z2+INpZiB@&ZOe{G;WrDzzNor3ku_r!ILr*?YEbI`#b> z{ECH6RcCjt_g-Do^E135t=a0(ehaM=B@K0Qs$_qt(COV`t-Nq(C~Y`Z&Nyjq&k?6+Q#=0o4HKwJHvod+&@K? zc-@BNanm*I+BMa+j+rIAx^$-8#HeLy6L^95d2+`ZlG5}zE%!5(#^%i*5NMJd@)a8=GMi)>A_iaw!qawwH6M-)R(> zGBh!i9$PU#eS+f#yWCn)mGx1DyZkX)KRsJ6tm9HKg`|>h_Gve&Yh<>!-F4KHNU^qS zSmtXuZ6^{pljekGcv#_OD8n(iOtIrGc_$*b^;;_|i#5^oi;KA@olKF=?Cop=xQKAlNuz^B$qG(z0d|C|PN$T^_II-tOneI_=$` zhW`L+-vT7fBsO;+v)_;2@FZgL;%(k1(IYYfLo&$a8!w#fz$XH|n$KA`CTaAGwT9Lh zg28nvwAUym1va#DWdT>{qZlJSYr_0Xtk}Qphu}rh8VyeO{uFPI;?#8L@hP+i#JWfB zu-Pg??U10r1+$Er_nk+>*P3>ps^8p04v%7A?Mp0@Dl7wu8~qt@T$A%CBN^%5y-fYe zlfY4_89Yb!UItNA5 z^v@0H+S19XOLn%}rl)ad8-;^tw}vO%kpVkG3=zBiVaqYh`YadcR+iIO(q_`-@+5+L z%NvG*)FetXa`y3UjczVimU6q_aNI~W&G>7@5%`NxXmkrpS!`~sS>(Br!YHqAC9##Q z=DHCyVUS001fn;_T@*{z`ShjLgx0ZKT1?u7#iO{@6hx-t>V3OaBSN{8YK1@!?m)m5 z!Gx(&6k*SY_EUta#!|eMR^>G%8K&%|1e$3jXQHw_YRlNhao?Ws*)F%fi^=GEUx6(2 zTdOB`X}{2*KVga^v_`B38Psv+Fu;+I%*34f)mGFs8@9aCEZMDWlI2C)+}j3Qh<6d> zTZSLIIQe(3-NT<+^Dhl}r&H6eE@p)$YqeKdG(5o+w(yVnX?&YOjzk3Lwe)WUyFCpq!lFjSur)3P+iEV#-Xk^tVCOKX{5)qtjP&xp6 zjAsWtn)5#qO?y7EHJry0$7Zq#VkSMMdEQFk@zkEfHOWauYZWBbI#839-!q3dz4PXK z-TB(a%JQS^*ED4pcOJ+3l_QcSu)27mHiRm?F*B)IA=xQ1%&Wa)btIFViq6ygJ*rLO zjaS6i79!%~UAc?PSq7x-Z6&>{u!0tz;g%#|m?$td?pzW@cit4c)4$;z)b*QdWQRx7 z?!(yXJS6i)125VHwpa{M{K1t+e4LEdC8vub_>*-NpM)OfQwF0go!dgMWRWvQ^1S9( z{nTbCRoij-wt|V&SG`WHTsz0qGUPE(ftmyy?TX-(iS}O-t23u(|yD)Nj&wpCR z@s^==Yj>(^!s;t|B-JhS9bK(0%#+Qd!D~F1PY^-nx%oM#<8&ISo57WU&>(KM^= zGr>k{@3Y3X=TnkncWrbr``MFA{6oh3=Jq z4UdNw(Jw8puasJh$2gAXOp+Uc=1V*X48kb>X-Eh;Y>%uwG}hPl_ty+mNh7b>%Mfo0 zWCq^cPW=tgT3#F`DTyRp$0&i?C6y49C-5K3dTlIf!p#9;pEGVN7xaHkdFPMqme zQhIwuEw$xwOSb<261Lyv^tfuA^W|#E+g9(l$#40yr|^}RhdeWFq-!vtveIuMiu(8M zWLsNaT>v7zxPlXscQUgie|YBu92(WU*L6P^Of59#eKSm!W|qb&LHkn67%rC*B2G=T-Y_6QGeVwd%c*)bJRmsNlbBcrLo079_C#CznyB3-j$szsYL1d#JBCKVdbN2%g=zfZrXfWwZYjt#9>elw;+FAjDEuyK~ zNf2>2`D@?_RBT7Pyp+lCvT9Trt z&wgmi6w-@c&0AL8`L(&pjG>8?saL5rI!ZBq$t7haCjF;1-SlftT`i;6Nv>L5L0ntG z_G@N05WHlMnG27b13BSGW5?GOt)h5+W`sHz)*E&)$R#CLBo&V!4ZwMudJNO`=`@`t zU$9?W$sT33OKI(hGI^LgU~suUSz*10VvE|gHLJ;z)?sUF5ZeSlXw(FT8CG(m%Vm&Y zOxu1#8kRXE^%dsP!zyldB(GBUxAN+>es;d<=uV@n?CGV;Z7!Yf=W8u=@3Hb{?W!b` z_Ez}U_RGmE?X7$=&|RPeY17D>g_Fb-<9AgdxXIo#o-3Kvd`~s}_LsLhV_(TFrjBfF zAza0OYYva6M=UU$9kH0vUQz(Y)xpWlb$_+CrF*D;%YPbl`?(>ycJNS*tu7)69yxWr zA~ND$H^|MgRZk_hfyw9AbZ-sG;GYQT7rMrfvb;J)u!W>-+zVUX7RoUnl5rvkQ*w`# zWVi#;y_`jUe72XnZfs?FuX}G}hM`Tz;rm|QOQpGOXU%oK4oa3PaFlt{!%(`vE0?ve zTgmAMNq6}ATVEL0{vr6ASJSOD4LWpPFJ@B4B^bB2+2x4Y`6eq;2z}h;bAf?gai-{6 zuZiw0LTOD)Y3k7*oLJxBM^RbN#7rduw-dDrqTiZ3d;NK33w$&vhKP zkig$FI>{8F_NnsYSlO@$C+8?scd05=tyVXKmp1B2UjFWybn@2Td9ouoI0?Cqw%S$}h++}lSOA8APd%(oI1{o-RFD&wvx zz9;c7h3@s6X>|QC>X#Zr{fkt+)6mCc^4&0q+p-b~MJENo=LLY~u(cg`Q=0bH&riA3 zueBKVwZGXJt?iQ8t}xTygT&Cw7;T6$Kpx{d_TCKC?C-C9Q{p6!(@ROEy=J#Z^QQ{f zgU_{P8HrRXsRIod2at1G(RCD?=H->GDJ68;lyv*j{{SPFv}w7w)QsbbD(K<(In?u7iv5|sm3MyJLvMp!JRH6DA{4g@J?_>eulTc zzP{Cuhcq2aP1G#xw7YxenWHTXmr^KeotlsQu#^L|WlD?#$2j>uZC2{*RK>rSEuHLJ zv~wD4wV79!g)I;64W^j=rbU zz7>~NdqGp>&F(n8LTF;WqYSa$){i2 zTt$6z43aFntRx~xl~*O3&5f6E#^6sp=DOWV?j(y=y|&XWA5yllySLNtL=0w*2ZVW% zqJ`W@Am9O>+}Ct)P_0gks8_{Or6&wRrmFKK)S7U;qok~^n$tzn@5*wihHjNg6ytqV zpt&5or}1+o->bXatEU}Ic#lQ4*KO|>19v6PoA#gV;d<6gq$rV5vBw!)WB@VRy&uem z!Wn0`oo^(P;&|T90lFAON?XjBk%Ehiwgz^BKAen}R@#P#_N`gulKRxFjdf;?750y) zzZT08fD-AqiC3H{!vHg0a@yaCtuA$465@Dn_dz_9+s1~?i>yvTiC2bvpOk-i`d44p zKeJrZr8>BJ)>uhFCcUanxK8czDP6TKej6ln@;dEux@(c^8P3jEYvEk2y}NZ=+?QDK zW`SjOajV#A4sPO@+}YXNk>yW$WPHhHe4ZmRCRuTU4sl**dv|}WJL^7UNvY2(ItaOS zJhWEn=*sv5j)NIJE0^&er>9A0I$MeC1Z9SyZ9Mq6mOvYLQJvw5`>Yor^V+$826&%S z)9+ie&t2U$8 zt4jJF^$aB_P<7OAE5)d4wX}JC=XbuBw&&QM9lD<5!P~W+DL=C{y*c9h1gsY7?*1nh zvfoAyJh5+l@LaI@a~ux64?isGpAa<5KNGwc_c~nKRhlYW#Xg?vadUZWOnX}R{nUpW zh#WpJ4<@xN{Ac0~O|GxylImO1E}q8D>QMIL(n-?Y!Z15hLSN1ZNMa)-4)x_a)`d2y zYO~F4X%*Yu+)F>2S77AgWEsnBY-0qC!ycge*sOFg)Nr(CT8yhwaH8WsiiJVq*UzibN7Y{E3GqwDx`wagS&xFDw3kJ>us>+j zMWMWs#_Bl4k7uOD2qNxhP!?7=SXN>DLavMGwK%RkPpe*9X#OFM!#yiYcJ!=ru;~;~3VR z3&OQ%-YTqR8$~$EF3Qqf?(Ji$R4}kssNGsow4r}@l5XDhxutuywzpTY&-l;BUJ7p- z=(mRA`tL`%ipX6<4c_~0^2V`EJ-KXoa$2!6atLgJjty|S_k^wPwS9hDElzZ|(?oYZ z9JkeG`+R!gTZ?(3hU`WFvXWGpg^O|L6rVWqhG_VU;V!9l;=4;P5W#Y~N=Xc++Btwk zOGe!c(DTLFlRkS4@E1JS()u@ne7_Fg+(R^$_txzV+%n$-B%fl4O0b5{`ozy54CDiW z!LL@9BLS8|oUo2nsH$>}NK}`R~nYBD3a>)#6aAkyq#6$Fk9ueq#&#dC(HB3!v}4A@A02S zvAn(go^<=*q8(e~mXQXxHI!|M?wdxvHuFaS8<%SgHdm%kKx^rr3f*gd8r3{cq3U+A zT-ey$+ctxA#BX@m#|*Y^Gm#QTpJ-Fle9R9byj~*4LcI(%d^h_uo*xqBN*b!4?KpU; zRF}KYCCTpED^8y1uuzpb;v(ec-AXC6xm)L@Dc;v=%h{;Cb-nbppS5XoK&u*rx0ZW2 z)nks?vknv}*%?1Fs*VD3K*l=N(FKL&+)yRQ*e7htwxFD~={a2YD*4^`;<+ta^2$5M zlEgols~cb`F(S;0$7_$5hm4G8`HJPQFXf9~(zR&rE@OF}7Hh?|4q|QsLaathGT};+ zNCe}ISLdpepTAjMP5Zlh^&OhO^50vxdv)CPrOc_t#kBq1T21%1w*2}YjdiG8X*U-- z)#UzDqkV?j)2{24Me`0i4cw9GyBVk~{8MQ=Lo3*sUgqjXjgH*JFf+mAfZ058jzv-N zF1_blBHW`nXIE&9dsZb*@&y}XX@CxJO@8T=kG1UNW?Bs5FF%S zgPO>>xzsh=i+i}|H*m(;ca`toOQgG$x z(MtaS6H9wq?|+drr5dnOsZYr+ZMN&muYI;YR=0~*((bj}4MO(%#ye}X=S6LNuc(_Q zUKkP%GQ<)T=bz8cZ@e?F$E@3}@;{0+zYu8mcA5lNEvYSxI+P@t-LL|#q5%EiKOy9t zftvTl)4Wu_5{`$fcxKGaL|;a2WK1Yc}6qRHcj0w zZfoe4xz|yjC%v~b($40$rK7E_)x2z4D>S>5d6G!Y z&zBmm=>~r2KSS=G2+}6GZBJU%bo)(G7t@l(Eg~d6x6H~ID`0L=Gm)QuwdvBfk!IFW zSz9gY&JiM+Fp%6rOvpT*)TSFI_^GQCZsckZn`wZDBjqncHDp~=eC+IMolMbgWC$ZhnyTWf9B;&`L- znkemU`MMGY^Dv~IK*8KgaDlJ}E6=Vq^Qm}->&&veV->VkR{_)+g2KQF0O%NCWRMQt z^+Qteg}uGS-kz7B>kTw^iMCIY)ePv*EN+CHl?FH4(Ot8FnzN^C`gO!D7M#LuUdr&n zsLCdiMv(si4%NmR=JfiC?!U6bd-Q$vO6l`8_HLe$-%I)!wS7DOr*m(om@U@wMU2V{ zv6!67kn&+x7{)Q2_ZVJ%Vtd3Bh~9raTp4!(w{!i}i`(~@B>E}#2F8;Y+0u9~q-YG- zm1V)fG7PeABOHPG69 zyR&LnYgOd8`CsL%-Y|`vpEpHq?`wXq{v6~5#;9bG{#137ebu=?>smG@Fb}2&BR;j2 zt4A&U+-qTPb8V%~J*~y!+mdHDz_^#o2aJ56V1d+e>&$C*py{u zZLach$`1T-ka(^89a0@XO?l>;?qba{Et-;!T&!-4WFQ4aDakk)Vd@2TLC&mHV+VGU zS8wd4A$V^s?V)n76c9uRm=}x)2|dY>79I1BYsqiEApZbvHkqbr8X&eaYAHUcG^c#g z#}k8a#fRRLDui`BjEtK1>$^j3YZdHY=?3c2=e3>rd(!J{e$1n&bt*wTfr1V&YkV|) zg;`A`s=eL(qOEN{&AV^tMOVv8GvA)Cv$on=GUmTs+UT_3q4AB+*|e|P_rRKmgtWWm z@kXorIr!N4j%HQz;Jdf+KAi+}CUeJ=8RTO)8Rore?&RwF{{Z|WudCkbdSnD>8-aG5-L=xB`^7kud=(-lcm>x!uuHhA~IRMf;rkDMv1;mC;e@ZxeZ5>&f&O4#eWj207$P{wHyX4m?;m;px%X{|gJDoO2^vh-! zaZZK_Z*6Uf!`n;zOzcS9R2+lp&vBro&Y^Fq>knueEoNEfp5AFzNDtYidsmPV#@Nld z*m(s&AmD>rehv6>;r{>;YVEA)Rxn&n%GNj9mzs+Nco}8bPtAaE6l9!n-n_~RE4FHf+|GHjQmp>dRT^H$-mCk*brltE zW}CC+du@MRH1qQDb>&u~`n$E1T(7mg-c@#zZ$`BL0EY5wB-3P?-tym2YsfXW^Wd@o zul8Hql7thC9k?Ka$RnVxKG(onjn=Uzh_7#FTR1Lck~h=ULd(5?;fTQH@xddS;(S}H#SVjQq1juZI<$*(tU$PB@}nV^ zFgXTABkpz2@Yi)bvW&T(v8O`Tf4hrZ`d;$Z`dd%&KShGZSB&K(?x)JX!)~|pyXbuT z;>&*p$ohAMyh&)$cvoH2*Gz`f!-7dS^$*z}cVW(T2 zD^HpWyDPmgTu#?(%q+1;WguWFAdY(VJaJwvquohssy&98r%i3)>nod`Ls8UVk!|C0 z=;&C#4Yu)!v?B-QpSEjL;XjTh)F-^O)-7ka(vZqDn}&^{B36)tZmvMyo>*q*8NdUQ zE4J12>pQFAYi3Kydf;1IS_R5B?7Ga1d1eaAN$>QhQx$0_$|_K@afdanQu<9hH>bO3 z?EC5{Q!G*~ok4^g&+TQ{#2?W=P;J6q_{{q4n= z4ae@|KDf@&bZth$Ul8e+Hqo-_+O+=wW@|E9vlWQOi(0P0pII3qaq@KSXsREve}6;j;R=5x2XcC>2S+3)b4ej@RyAKqFM zdZiZHy|vO>?5(0XKNjn9%?uGjmlk&IZVZu101i=nv5XJANzcDRp;+ic?Nn}vlNaYy2C_wQ7Bx2-%0XgbN9W#pZ4MzIN z-%WLMaW=?ETcc`sBzPnt4!f0ue8YprE6B{bb>?2lQ&CPTT>8FS^pD-p^)MdnKX*4b zH>8wywY0NuwVtbgBdhS1g6Uy@73#&MU&j*aH|Ze;SZwD2M+_=(;T?0dfzAn1Ym>Lq ztTbI*UR-OsrSdaNs#)o_XU~Qe3|8I=no@j(pJ+sR3IYjWc&#l%Q@zs^C^pu%S2l|4 zaU9-k_V$pmOK5KiCvjoQDczG?cC#!u9vrZ^)tRldhVc%ZZ)0{g+O_O9R|e!wZH&3L zX8}sCRk8*-!Sml=PTC2&-0eHbuXk-7msXzLdVI#&_`cXl ztZP3IW}84ugoYpOt!<&P7Cvn66dG2KZf+4BWr!5j3CO2&3Y3s*~TYNLnzA4=67q`nhK@`^dOD3l) zNQoW7sJ5R@fpDojF_7MC42J=Z2(PIo@cxhCuMFtE0?=+Enk^zYq*;q87%Dd|e?mJN z^sp3N7<+1wPEO5klCn>KUZ0s5`O@Zv2vcrSsP46JbmF4lG_|y((~Y)dHl7L6@1p+E z@imZ%QgmA>5+iL4>fbzVAS$ZLp!tSTl{hV&WY<@qSWlwe-NxH&ZSEs4V>PyXsUZO2 z{K4`t>6Qej9s3y1h%M~&n~1M9B)htr?%LkdN?{pD;D!&LR&J_$~{$`JPd4YixY**F+QK?{k!Zp4<$5D_2(aA#PVMXr`6-e(Fop-Cud1C-m5 zlg}ONhVaz--L9IisN6}azuLFSV|O8qVlv7+mMb9y7?gp?80WV&sbv+fh@eeFPqd2F ztX4~XLN##4;cl*Bc&BA2K5CejH6#9dk)CTG#g;n6pKH2%i)#z3StGWvWN`|{0uav0 zpWfUgdydnRKJezM6f0D$<;%%;9%l#4>T_Dqv)*iagH$03Tg>dU;#= zvEqNVC8nhR00aIgErzM1i&=D?79CP6tzHF`JiaT^rCWGW8Q*&d&dBzLV81SLUqx$r z=C65pSX{xW$zd&{U1@h$1f;gn*g%k5Bg`Y&gj|#WmdttJuJ6kq+J^4iUGRU7-@~U- zeIvuMcy=9AS)TG#k6ZBt&x$m7UM7eiEWu%hVaEb;F<-DyX*x}&qY%FGmgiH`Ebn28Fvml&aQs6yDKrRAXeF+MI8?JU7Bt5cs!M*W}c^`xxz~Sw*eIyTsP< zD;Ad8&Pf89U@@GAk1Nl$ZA;>vFTssxWu$45Ur8;%veT}mj!U@2nvK-({hnDAG!gEM z0~}7<-Mq{K4lC4N%R@*XRI=49Bb+nY7(O9?JN<LdS;z2qvbwp9G_5-= z)w2z%L~*A@jlohDt~IL|ZLD<(qP2k_CM`2dwJ9vp-j(v5?e?9*NmO~Riln1C3^?bK zn^m%pQMR;bFaH3w^#+|1-4a=>w97tPIrS;gT03jO&l8kw*d0Y_X_{^AuBBtBGU@t^ z2FZ3!B!FJ&jzRwbRcd}m`7xOf%nv=O`j)+<>H40VWoZq((_YCry|^GWi5h}(%rmzn zai3w@yh!5e#dnSia2~ zC8dNGz@T^tkw}M6zff(vl2p#&GODW~{wA?$Y^5?qV(~?p3fkQ-m}DcUL&49ZVzazQt?IWI>vg5w!*8nH z#-N!G+2D;A8JCjkLYv%Kh8xt9>>@{9y*R>@T$KGD+^zF$Sv7E)_0Z74r+X%8i~> zyC@uTM<+K=64?zBB-XF={a*Y``kEtI&t~f;;cskYEMh-q!N7BcC#R=1uj;zJ>=Wqs zT7}a+&8*9+3w!wEJB)0ry~Z{d&&v7ZAdF(T?II0hOBRPty*iRYtX|Vn-8}Jp+z4(L zp#zY|s0XMuoeWMAoF`ik7|vh3r4DFDPL!|9?ISJXtFiP|zNXr3yq0n9YpX)H7gOC&14}+xN_jEF*ig@mfCf~R0M{4ePZq`Y zIj?R&wzaWCZ4_37G`AAZ^C^uN=96r!H|+;*2sNdr+%~6Z^4&Ow=@lcEIQEevKN}@&s4wr1dpe@ zfo`;$n_G!j$&NBXj^0S*`M}_pT>Je?m+n*}PnHS^CX=&Et^EB+e^+sQ_HydEla;i! zmD~QeN6~ZZkk6~gHH%oxR(fGJt0H`+@^=JAmq+EemQGb6M=zCZ1B{L{Ucd1-izJNb zjXjFm-AkgalxXYr>roUEOzXFo`xsd{P<9!caTz)G8_P{1-b;&nh+0W4U z&fSX)l97c(KRWF_OIMb7nkBcF!xwN`n^|<<6)bU!d!uisTwmW=-2I)d$Gav?CZOHk~`!KXrT7z2277Yi|6H z7V*A?tm&R1_#B#)65Cr^{BqFV+UD@i*H@GO0AOmFir*k8Kg0(tN6ZEWN7k`h-#)u> zad@!}C_!^_@?JbkI<>qT-ZWxH=;Ii6B;`q9*v2d7f7&|lOSOaGE8Vri#UIE03PEWQ zc+SC~>Pdy4C8TGah+Gl!t_^t4-$KD$Flj6UI`k#ZQF;hwrNRN;w+UmEpR8Z*M;+LWOwCpC)1IMcLs zT>5JCN!{q~anr2%u~lJB)#a~;r^^X$s?z3^xtq7R;FX*EUF?snZ?!9^po3JqH%%O; zY+6ilJWBTS9k$ngb^vuF=Qtz?!oG0ep3^|E9w&qQK3n^pI$b_U?&Xr*?c|DJS9A)Q zJC(u}1;oa7O?doTbSs(yW~7MxMi&z4k*&v_G>X1t3v(#K#rA|DZ0AvA~5R5;jHDG85)qANgk8^SBT? z72#T?M=VS_-Z1GKTI=4kYy6SV%@?!3q}TrdBzmNFI$P;c>kvcdYXOxsxuhTIR}XY{ zO&qKDw<8U%xXQK^^Vh<>T{gQ6*LtPp?cL^|dXcw>^r;e6)9tlr&gQ2OhkpX-{nsGmoDSl>Y__c|9IE0e*LY^>`yNV=mn~&h+|5ZX9X?xI zZ{A(>IM*%R;-uqeXS{X4%J#9w=>9jiyzw24xNGv(I%6Tx?b1bpd#O_rk1hWIe90Lk z0~(jd-1&&DFA{2ZacR>_Ya|li#VnE9GDkQt76qCO=PN9+gZsoeWdkg#02St+8?H3{ zFGRDp@Xec>{npYZpcuh$ZS0E4cjn3nAzmol$a9dOwm9Rs@b0VOkBD9l(XTG9bhzS&OF**-iluH zO82#_Rd+vSN^TNf(#p+B){{!H6CP=h1gsiDQ(2#lTeGa z)9vgfy1BU;a$6;=-eh1rGXCxrxI_bdjvRd(o|V~Nh$7IDFtARs?U=JDWo|ca86AK6 z_^%r`#m=TGX-PEJaZVJhB_LyanvRWnput0Khrv-M3>~3!+y3@YR3pKQ}v~2FGL`oD4*{r{E zJ?CqZPw+3O&!6a*$tIk(kR*88URP!)B}2IHR_??Dv~keZ#*3?I^TxK;_eJ6pd93of z2!VyxITdAM0V>b;PbZ!ZE6SrKPIFO(l$F-Iw&LBlyVIbta8u;9+rPq{-LD;VZ@1w5 zt>=C-)S&RI=uk&*6cTFkT}N`#u-rFE`^RaH0R(f5_sw;2Y4UiU{v9X78cXXJ)9DuX zGTJQhTck)Cnrq1&&-$2B*l#>9?_=CX^af8AB)3Uxf2K!ma`sDm1?Aa}JD1aKr6fGD zqkO((k^HKA3?HVih8TEC%ll)(_bH~{wwmPXcM>TtY4f$z_YWz=Fkq7+bRZ0U+>b{O zDzd~#NF2oEhB@NBPs9HJ5Ek|u z8Cy@dyiGbob77^M!6esGD8LcP88OX}yXB4z+Z5&SL9QF)5z#z*p~rEiOJk_&#`eg~ zs-`@N;CUIReK~r*=~YJVa(ZJm-DozGT6id0>G9j%c%w|Uk{c^C5(}Gai2^9 zIR?9%{{S0HqH8)`-R

(eIYx2h#0f`(C3wqBf2=tYcmNY;v~@VpqZ8v4dU@;9VW8 zzia;h4$Umrnx3Pse$W2^5FyuA;ab|#&g$F5x>ud{AaJrYMsTddB%Tg&n){E#UkmL3 zwm?b0+W!Dg)qi(2rjaa4^IyQH5wl}%9AE`MB1pY@*7>4@F?5tE%Cu``SS1*x8^yIf zRHg9p+RjPdH?z8SIk2vs3RC8XC;L@&o~i2L_-MbTTkvd6;@=8snpTpR8a#J*uNV{C zZn?GwX*S8bs`nUF|o(p>{{hw2NduBsC zXfeGq6iAVV{pRh&6N>FT8{wNvOZ&V1Ev#(x`*y!A0?Mx{-FbdsnPTm};K;G?2TXjm z+{tO-t9wYiMXF10b9V%4wvkNn`Nrl`vRK4JEUq$1&p5%aFAJB}rFzq)X9?8yaFc2+ zG~$$;OcVx@TAdR^b_`^#r{(B)-l?sQ8%QZzcP z?3c!SffSmSkws*^(m9 z=f@aVl012eK4wrku9L=^`dEwoCf>^43uS^0LrRhG79hK146Ae}nkiDPUogT`yOlLk5}Y28e3rCZ z^=)pu8e!r{`l#SPOn+hyiaQug0qNiY_&TxeQS0Zx$V5>Rx2Ax1mp>ARdcw2FvMWwdy02}ejsZyUwD$$twz?oMYoSpLnLVDM3Fi7rkpQMe0 zOQ&-6w}-V+6q?g(FMDFj(Aii`6GIZL11%-R%Z-8O#uITHi5TlwEMU_$3mZ)zR?{as zoQrWi#ndb%v{1!`tdqND6^LU2q#`!w2E7v3?Nf`1=Sy3pSlQc8ERb74EU`|0JD%hCVU4W=4FeL`^Hlv?v~%$y<1t}2d z-*QZm+(io9ySp~vZX)wzjc{=11J;%s4H};GqW!EYd$HyBu9PJmEqk`ry>#5VlBpkZ zUh|UETeO-=%FX_Fxzl)N{x~&AV^~e>F;4e463dz7Ri8PQXB&hFyzKJ`35Da>&+~7P4%)wnCCR$!#iggF3};F5Kc7&Cl^skt7y>=v;>rJt~H&?GC5g3c@5k>=?7gXK6Hz9hDl=IfU zfblY0+3EU?qDt0s>JvwOZw5!%RuTJ`^JUM?B$>bjpHp5#r0Dh&YXBIi{W}ag-$rjY6j^RIJ@d#l3C2z4!7xtgfA*Dv^HY zPH%O#?6&pW%h8kQe3*n z64_l_Y_)~(i#)2N{n7>wN6J_XoB^7G8>@SrO>J+?mas&3=jPiR#=d8iHsoh&kU-${ ztf!BiIm$7ohf&hbRMgbJ@Ht6o*4y3Q=b=vpch0KUZX0VBwM&0;_S0+I@hIt9m+cGT zeGWelXgasSt6O3xySdc$KMv~?>K9Tb`5sd);&OAcHC)NZ%DpQ-Ul4xQI?cMxrt2R8 z#jFGtxt~bZZROwdlqPp=xRI16mIF!iV5mHgP4PSyi=f=Dohvjy90S zPF+V@>%!wJ;+!c)7+6M}qb2Ou1WE z`|q~89G0o^hxVz_r;zxjFM_3_mFqv8t|Du=t|Zg7F$}jB_>yZoDRy}#KmlH40G{>p?z{23K{4Lyx`m&K zU&Jv>hteUsUnF1ZQvU#ENoOq5WiIW~JD}60y2?aKz-?eye8b`u@fGMAWN{@h+ibqH2F? zNzzr0;>vhkR$nG3UogyKF|)>oHgS@CU&r6JhsBEvnDs4FO89@O9Y*f@(e(cSFIBa? zw~|PSH&9qytTS%6VyLdMu#gfW^A9!5{5tUuihKd#?HA#Hh%_q~u<D*j+%h%ovPp6X0ynf-B7yDX z0ht_zVB-MoHRzCAU3jAFMW0a9FI!Qzk|fb>G|1Lld)QRF+CzCT%vMmmM=d1n7BE3O zs^^NPsZaMff2+FEt;;+;3a_3^md>SURGgEay&h>coswxJmVZ#C&Ccat+J8K2$`e~H z9X?xWb)~M8zUNb>`1AJA*QV3#Zay)55)oPCY0}H^%Jwaqg}L7ZP6WewnZ`E|RGj?S zt$knPPwk;5rKH(wUl%?E*iEXn3&8DLHl6;b|M|oSzkSX&MXlGr8SlzhM zd`aPH?jy6(^t0kStt$RqKGNc6Xsqw$w*s$_KXn@@-L5Hwyh z@lHGsR*jqqW;on~nM>%c5U@T_5~5 z_N%GGapK>IzXiNI4eW_!ZK>&g1(Q{RTWf&EE0qyl%+TDn0hT#c0)n7(oO*?~!=KvQ zPS7XRz_Ju#%&e}f&2+k5*U7md72r`g`=QeMZa=&((2PxhlI zy3?&K<&;}XZ#X~cGf4zOWra)1fcb2pffeEAII6dmRfNjux_Z=?_I?}LxVEG1C+#WE zS2qarT`S2hsU06wj8aj=V`P<*hu3imDQKOe8KkYUNm+I{on9Z?FG#i1KeawE{2hkc zYdps!UkmRN^{`2#2hyMGIKANH-j(4fc0zlEmkF5Bp*_+xXq z-V!#;=cMKqHyFvpgpBe9T+w_yy#?m2cA z?JHa3gqK&h>T0NIt!!((tfh{``?^P`v`@aCUw@DIi&Xusd==nppAl+56+RH^{{YxC ziSIlyr~Ey;BT%!ny102R2B2o&633^-=M|e{pSY@DWvV0rxU9N?sTv%x~{{Rp4*rB}C z?XB8py^1mW`&itGTHkQoRTP3UGtFsA%K=l93zyQH#zHc01BFtIs;25jDbuyrDpqT& zPocpo5?F~+bun{{Daxc>Oim(lQjDOKV&x~wtna0pvUe=_*WtJAL8PVDtvAOngx5EB z0^Z%U`%eIBBkd8$o3INw`B^z;2jvHnD<@1Jwl14FO*i6)!S}eE$+WriJ|A2?lxXS- z;zK^d=@=!FHfb^d+ny`kd{L`Qu6S!oZC6yfg7U@)?#!^;#RQtPjcNzkM**UZ+<9sn z3^EAmUTLB0cM&FLveiw3U&V6P#7G?)Cqw68k1(kNm-~ctIVP~7R5$-9z@z@GY&*u@{NH4S2!L zMrgEb^>3zXYMATxrGf$!T@7y`OD9qe)))jBS>V z_}oR6t^NBgE&l)xetl^AhwWjmMK-Id>wgM-H7>5uT?<=p3SHdWUuuP#7~pyBq;|JR zVriN$JjRTQ**ld*dj^Z}-}b4{UhiMge0}hGYwLKSx$|y33#f}}y!j*ZV;6ErjUj-x zNEu8kFk^wASk~mY(dO{Y=Y{T7bbHBQgT#7tx?|2B^m)Z6vytQ2At+=9NRAY`^P1-M zuNMW^FCe?t^$U9&ZNe=c*=|-?Qb@>U5Nz8#LvfIp)q?B;fnLmW3YC?q;BZ{B<-ArC z3b`)T;;Fh^@0D$amrYy_a5V{yINf94CqY0BJAUcSO2|2|gzL z2h>|jn%_yD&MyS&e`Whs$@0vvAvu)5!!iUc7m|9{FMs<&e%2{!bnR!x9|EG$DT(jjg+>+ z$5(+TYnbihSr5)3F*KhrcI#cm_r<^3>gwH-RKNHkJ4v`Dn)qi@b&5FWkVZ`DHfo=zOi5ZY4*6{0h9(JUwNvXfJ)H+uof(OQ~31+rb!n1dyM!SUk9RLdAd_5E+PG zT;jc++gg*vULWy7=o+Pk-l=HU^2=eWX{+{>({1e}Xf5p}XNXNB&9@sj%2rLs!D5c5Xy>S1&1+FmdyF#3@ve5uA)yllT|n?w4nx zTI+r=w90-In z^gDEk3NnVYyHPT)+6Asw)zgw>g~=E-t)}>2Q@HUwGI)Zx!PVr8hrI%2vQAs6!pbk*9bz+TJ-V7E5+(H;V4wV64Amk`{!^BjEXD`HhfIr0BYY zkECdtj;*Zgm;NAF=f0lS2qBIurI?bo*0I|LCeqv;vB}B=QS%z{@mP#aCmGhmV4JBG zCCz}L8^c7WXA9a*ZrjyaJM8|Y8A=hJCmiDMclEle-w#yM*LQy14pYRM*X_yS7;K}k zpZ0$7J)W}96k3h8gREIxX);2&w-<4&fz?}|n5j|xOe>wR)PHW>SL_h@lKb{>({0cw zveYeft$N}sfWvVYY{g5rm;&}*a!DCA^?sw`O)kg733;j9MQt_SpY}QJ<8AUwa7W1` z5rE9j2m#6ijApSkY3G*4$lk>mXk#KvV{Y$j2?GI>HZbJ)$Z?{%N%jt+s|za#pTh|fSXAE9>WRf_Hf-~l94)4<`o(E<7L2J5pk*=eYqjwm=T`jUV0_Zqa{>$sNw&;2~_e@h&Hfc#neTTi83UEBDJ_I?oAG?1m8 z?}s(}i-)yUS8ISRyv#=$zbbI#unMHt2RH2*`$X7y^?n&&ufc10wMZ=QEH!oTABexQ z=1oo6B6!n_=$)E5q)BIjC=kQ8S5}fB{{Uk6BUSL7&XYaJn@-cGYu_#ynJwZPgh&;x z5*AEuK3H<#c1#{=pAbA5pk3;I9Px$S<(-7urj`Ey2-T*gXBE8ZZEb5jm$tw#+@-d} z96FqWrYvV7xv67mds@rt7$*vl_H=ER;qM8pT%YdkX0*RscVhm}gruCRV;btEjKnxJ znzC_~Mw;z)(^Y#MCcA6 zn|Rm3{{Xdyv!_{Tm%kGJ6GNt$qc>CO{uS0CBGxxlwX?ZXBFZiAJn6jP6LSba#eHYt zT@+h*Mmrr##JYcqbt@a0Zlly5J9N5=#pTVlvTgZ{hk#cA_Q1vi;?u8gbsMXz>#J!r zSc(a)m3Q2&!Xr9GaT4Z6TX!)P+M7U;&UiTT=;qk9is;mEhIy zs?&W=h~Vf_T+x+Ss4kUSak{d6`b}NEJ>_?%&d0_2FMz*mKLR{@a`@lio!ymHa9UyMG`21=H?bVZ3cZ*TH(P*{+kA z)o1gh0Vj(ELL6lRumm?hU0>=?ELQQ}C6JaR4|HweIhe5m*USVGSrBc{Mci|W^6wey z5k|KOccn=(#}dwAa9%frk``nuoRfmPQ11D1am{*^@mPse_LV5$?>5z}>BpAG7oew@&FhgFAB)fsHkMK>1+ma0|umVBsD@~(YZ{xkm8Z!Vjn zooC?Gc6yz>i)`=VO=%cGWT9ugbS$eJD>|PoW@Mg4!z^vvV@mr5qvDMv;jsHu7OQd} z?J`Ne+CqrJJ4o2eSPEOKB&@0$3d{1p}cO8S+CEc7>azzu*Z)X+ctBi|pF}9f1 zGDi0xamme2CpM`ma?cHy)=;AeLQe~Zq~q-Lj8yqjw7H$)_qElP&b5?b(&US--#n@} z&&?+4a`RuBEm>Jv+Uf549%!Ev{{U@^5SO}MukZ?6YnY&f%@>9BB)hr^3P-%#{h)1p zDaXr}z+>|^Dk~p~AGQsg@@n@!AowE%#7*SJn!keegpO$l-H@|7t2a=xsPfJR9=g3& z?t8maCY`5V+9}8(hTmJxS z+oW+@-}!lagTHE!dG^`Owx-sbr-sJBykYJoVHARAP)JLO519zu+%D`O`AHbBLY`}U zL?}|jVAUCoa%bi|jo8mXXxo(o?WsZBl3hQ5Cww}~(p406^D7yz%2g~dvBx0%Gc!TzaKWNQw>>A~# ziasA($#&y(DdCMqIAxeNTr;{Vlb@A3#a(6Ptt6-DQ>UFSKNMQ&TF-~Hxz>AqTf=hAXL~KA z?j7fv)kp$(*QjW~1QCk&uo=Dvydg^yMw*k>tv7U~HETLba&JwQ-2Lyk;g(+rO~yXk zmzzmx<*oTGp~w6=@qfqNd*Ze4fNwSb0EQZs{{Z|Vw!S)w;!h1;+J9$TUEZ#l7Lc+c z?~>|Sftboch$66ORv;g3yU;!}*lSZI_lSNP?u`Y?UOkSqki|XJa!2+P7>9GaF657D zvb3dD7_m@%li{t_q2W*36)Iqb)!1nS<4c=mAc-XT&gp1GBN@qZ=G8oD8+es=416- z(yVaw@X^D|3x&idIuzg8u+(EAi(xv+zVu982~#n%7rDQC3g3eq}BcBWpvW$j@e)$<2cH0 z_h~fa%WW*)kI(S=`DUl^hxVwvj4j`YehOc}*1|ut+F5GS1Ps1oe)J(#Xh!EFa9~#* zc&j}Qz8-!xEnLOn)?^S+SR}s zuA4lTsRV5!Bf_l|gvgs@a*|?9d7mx-`=>oC$Gla26`{UM#d-A4v%R}HIF2Te{PJ_3 zx;C7ShpFb3JnpolskqXb=ah7%6%Tdm8^e~)4Oyh`eID#oFjJ2;KWRAfD9SB3^840q z?Z?kedv1K+9sRYlU)+CcM+~;tX6{oYK4c-^fn^L?%qpjx1s!U%8swVBr)wjs!9ASw zOC7r^$M)uu9iDj%N6Wm1QGy%$wV!xwKeXRfOEV#!W;)`?tb_YNk{&x~apd5C31&hL z4mhqV>hgHC%_0LF@eM-x#W&aTSI3B+N#TJsC?58 z?$t#3%CdqRj3P}v?67mSuP(9BtI-|)6D8?%R=bk+d)Zc7$r?+` zdolKS)5;|wK$Af%b8bPB9%Kc%$s?P=MLN+@_gkXddveXRmYsS(LaS7238bF7ukKl1 z&%fVp$CGNl9MgO~adoZU$76qgCz~zu*+p+~1kn*3mlpO|XF@?UM<5@4L1L;44g*&3 z*16(M9!)#K8V#0>pf&sImlrpRWY(^=X|57sGvjfB8-)2LI!>NYhk(e#4lQ44lQ_kA>e%ehg^4i*1x3bfe1^8`<@0+xc3{@U7dCAuh)I}; zmuYs-UJ0)X@y~^qK)r)f)isEdSBu0QxV*KIWsTL!JRrk@OL>@38{4lo zsbSP(6)G`=WfdJSrTNy)`_Avl64JlAlU*DC0EYXH3qYGh)AYST{8BW{DhsQf(%VUD z7HOW{lsiE*s=*oqBCy!NHuICfuVl0Fpq9c-55kv{L$WAZ(^2_97F8hWcLBm%_KXJ2SX?Wa&d*iZk*d( zvvYA;B;6~e9*tYS+W3ifTD29j)xRXVZ@2Wzx;@{DH7nUXL*hG&oBIoEDD=x|;)KT> zCe}YPdF&l_{iA>U^&oVtogsZ_f~$VN{_meU7fpi?2a=?vR8R8JU67w z`f0f`>XP0~BQB!0rIyuFGaHchN-~k*asfFN)ZW8xx3*LH^UD>S_WGT~x_91&JL4>I zLoKlZZX5T?89FL*Nh1|UTei6H%8NY+>XPdBF!{1Zw`y&qyOS}OyNPnPvB?B%s*#Bw z%-VMHNPEYqO{3WAR#2vmcjTL0Ix_NH-df(;v65+SqA~e%!1An(^E)(qwnrI7SFG_g z)ZpbgMpWu0P89DKDRVfr8Km2P4fRUWif+$%g0$L6B$v;pWVbynd^2aP_(JN}OH_gz zIHZnicPLEP7-sWX0AI78Ii0W*?vQXxSBL384B@r$6{OxGxRD{VBKp#JCT}|8Sq@ss zCPf9~UV0Ts2`(?Mb(_ei)-L1{!wk%}@x?o&EUO$~OB<+AFhJeZ z;=RjI@Ej4dO<`ega|Nzsf;j?5=ZDXmGR~$#8AeDOR|lM9ikvoJu=Fb7)G9@|+EQ-r zQ}vw*;ZQ9n_{f{>BPOIU|4+i+lP_@?)wdgz{;yo(G>;Mc<&Iee?jtA7J%LJ~Z~9ho+O$>(x6eEB$KJBJ4xR@aU+{Vo0%d{EQ~ zj!87{33!_DeVX3VaUr+UjF!Gxg4u=wBP^xa03>ZJGmhKgmV;$)@O$C>?O_eA=DYCg z!g`IlMoAG&+F&LyP_af55X`vRRAe@I9+Q&#jcG~~hx{qQ&zk9b)cvGaO%}UPc&o^j@?{sCjC((nc9sWJ4QnMpnX*gFBx;cyz^bR^AuXHJwu8EqI9}j?}f4 z+B3x^yk*R2fEdy}%1+`5+puJ}Vd#)}GweDgq@EgtjcNukPM2tY#VjtsJjJj~vodZ9 z5nGZD-~l7b#JEbIvyVIGlD{LhmWj9LYrikc*XHGE-6pKp_5FTiI(DCJd*V$aNsb#> zPN4SEY0D$VP{@~T>Y?&uP_Z!uOAY~07?2Mu;*SBtABgn}Z7%3utWsXyUfMFBA}C^G z_NXFp^0ctHX%$ztFnS8;bpHSZ%cjLL+Q7q9OVN20*O$yz*b}&{F~{bZ)&@RwO3t4$ zE`Pdrw9Ow^i&vGkUBRwxe7h#|ph)MLzGa>`xA~Ji@AAGzIVAcHDYr$!&TcS@vTeJh z-k*Z#FLv*5ee*TCce4AR`JQQ|_@Bd9nk<@$it_H#-bd3K8DlWd1HyLff-uCL%%!)m zTq?27a1WPw(&J2;+SkMyW}cSrC6d(LzFvPM5|X%*RZpFi`6?fR?lI~;x5Rz{4F$^S z&oz;`TbFf#qmJuT)RA3)Hjv-s;A5w9_ta z^$Vr7mhSR!v%SWQ30rlzvJ17m$>2r{AuL;HZ(9pf4JfMq*0f~(*;7e!yID8P^-o*u z?YCWWlzr#R2;0l$($D(W%<*k|#9kVEOSaT5wB1ehiwUiC_}?&Uma)W}BV%zN$j@ss zmk|=c$p{yQrTQfTJ5wbbB&RW2)7S8rFt>jEDwAs47%)W z{v8opYPTLCTlIn|Z|-g04VLmlA=;~T=0d6>5(fyRd70dC&{t*P?E^^FyeFwz-6hSe zvi+Gfd2OU;Yij^iuWl^vW6Ih}@MK!4QM?eWgQ(&BAMo?UwzIvDi#5Tk+umwW%|4kW z(0w*ZC7H}`bu0e%DMN59q4RA=my;k3lk{$z@XKEC-lu(MqU$!d8W?L^*>p=qV=dmZ zb069f>xPt@*EJyIJ=V(rvVo zdSAQK%dfBGSI{)8YeluO)2-fJ5XB@G4SdKQE#r58K1q2)bnUuZfw^%jFdYD_pAq<| z%L7?>e(O%T)ol~(RyUUf9Y0RGor*BOnGvO7fJ8e{)H&dewcJDD&6X3%4VBE+S4i{R z+h%AKUEIv_$j~|7vAR2${J7)t*eA?#PI0U>J5LVkx3OOMXJp#kP{*Na7h*AKDUESG zoxuzf?N9>Jq?-V=FBIL1ErIl<{?Pab8wkSiCFppfm`fJVcWCp)r7a1XXk zaTfB}MXO18^GT^n?+J=K#z`LD9Dk&JonUlb(sm5MV>!ln+}3Y?$z=MSl*z{gf3*~PcCV;@ z%68AIX}%xPbq|i7CVfLuzl|CzOYJMcm+NgCEVx&O^5~=?8w)<;8z{-Ell(KY@SXOV zqe~8<;%!3KT|#{lI|dfe-NSO*<(<;l?26f8e8R$A*v_tzB^P_N?XKPL_jEpE*8UXV_;Wt5~XWgk@4LrDp{sthK$g(Iwx= zQJqd}NhGJkoNv1(fmI)vUCf3l=~dob1W&SNpB!Ud&`StNTrrZ5G*la zozr*C>bIJYfpm#rWPL2%%Vu8LBMSq`6A%H86;X#B-GE{;S0=ni$68|eqsE>C@g|#W zvT0g5*Yw-uRhC&Dyg{X|nG)SIPiStmrId+v4L(ez%0~{?Qx+eYsyLZbO9=`!6Kz)I zYNo#PQbG{*I;Np-Wfre2 zOLutEunlDlAj#)66Utd6VydWeImLYi@CU-T9tiL>{s9r`n#I z8`2BwyR~K!+ku(n1aObR+5+-McXT!M?T&=0roFB0{MT$P|qB1S5{ za|1an+21R0IIb5{*Q~UQv!ZG7L2;_f6foO;rt&DQZsT_S`&>yQtcG<{mJ!7u01!`1 ze1z&^6>d&Q&)(|>(}H&9TKaYS&qvzIt9-3Cz2>6c%FDLj=6NTGd=F)zX;M!$&)Fl= z7f+7%Sc`>osKnD*NrE=)cmlMH9PKPPCm?dZ1G`@nc#r-O1eV%a8f8Yuxo~tx|n2QPF%|V`XBul6e+$S-a{s*VbVsdkJMj2x$Jz8-!AR zQwqk)*lZ3H;rE6#JtxF|9`OXS{jXWFyO&6`5kluoh+QJAH}7afYO=mhrwQ$O= zNek`aqe~S>l2rYbT2r*8Q%F>cUhAh9s^m>ZPrlk2R;}#m-cjeaZJNJG^ zH}M}p@Xvzu%|$gen#R^!n_IbcJE;7-SuV^)3~)-wcSx59%YDUFUyaADN#NfAX}%`# z?wN6W1d$}$q%d5GKYj-(a#*NODrLlq=*1aZaNyUs{85g_#23w{Tv|VjbopY9ZZzw= zc%;&F_gMI5w~f5^i$A@ZK^c?J94ic(x#1gqH%ihpsAhYCZ3ImnzngHa3^AY!6}OUA zS_@c_LPHrPr;n^ z!;r>g&~*EVcWpvXwwG77 zt*iC?PL64`t)jBgKhNDf<_{3*?{BC@c@&8%+|3=~x^0PXY=HTT5I^fsCV5;Qz*l=~ zZzNiMuh?v@mrFLUCAIC+2?1FYmTBRUc9q6NXnwrm<>zWXvqs+}v%7 zJ8M|kj^vhUjEb^D5yQ>q5WZTzax3Y-?HxZ?_8 zzr&s+)vqpI#`jOMxl@E_VUP*U$DM95wFL4;A|R9eWG)D=H1o81{{U%Ej}qO%<#>X} z!k-VcOW9dTj(sX;zIa~IalIpu!;ve*t%81DPCf5e78*x~?CqS|h^4pkbjvNK@>Uak zuFX5_F_czmHsF94*NXKsd?h-Vl}>Q?p@G0qyGs7<4vKuwtdnhiCq7>r(a|QBBD#zI z;;hsj-D78a{FbMe_^;zUx?5hrH3_UHNd%Vjd1b!U6oe>9q6d|f5DVpYfzZl4MOT`yS>(S+D*g| zv{A(YKQ*`#FxqekX4=@#9W!#u8|kdku_eqW$ zZ?%gA}n(oDJ)m0?Og7!;#sfe)Nf~! z53^e7`{1*MTH@g%gt5JNVr2q-s$ppXYyiqvmTY|b!O2yWuAE_7rAHXqYg50gcj#23 z%ACKNF^;cw9#!joH8{;`<|`=dq17asOUWU()jr8-7G0&j7%6%%rF@`Ck&gjEIpZUY zz0mbNM^LnBVSriKG*@umX>Mm&)6Yo%0DQwZMvw0kk=Hf6+N2j3i>=(P?b2#i;$3Df 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

1U(aRiH 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