Game engine setup post

_posts/2023-09-25-setup-for-a-game-engine.markdown

@@ -0,0 +1,124 @@
+---
+layout:     post
+title:      Setup for a game engine development
+author:     JackCarterSmith
+categories: Programming C++ GameDev
+thumbnail:  engine_tools_setup
+highlight:  true
+---
+
+* Contents
+{:toc}
+
+My first point of reflection was to choose/find the tools I needed to develop my game engine.
+As I intend to use Direct3D for GPU interface and rendering, my developement platform will be
+*Windows* obligatory (but maybe not, see below...)
+
+For those who haven't followed the reasons behind my choice of API and platform, I invite them 
+to have a look at my [previous blog post]({% post_url 2023-09-10-build-a-game-engine %}).
+
+I'm used to [Eclipse IDE][link_eclipse] for C++ developement with [CMake][link_cmake] as project manager. But 
+as Direct3D has been part of the Windows SDK since version 10, support for it will be more complete 
+if I use [VisualStudio and the MSVC toolchain][link_vs]. Sometimes, for a quick modification or 
+comparison, I use VisualStudio Code.
+
+It may seem superfluous, but I always recommend a large whiteboard to put your ideas on. It's 
+quite effective for me in clearing up the mess in my head.
+
+### Direct3D and DirectX
+
+Throughout this blog, you'll come across the terms DirectX, Direct3D, DXGI and so on. A brief 
+aside to explain exactly what I'm talking about is in order to avoid losing anyone from the outset. 
+
+DirectX was developed from version 1 to 9 from Windows 95 to Windows XP to make graphics game 
+development more accessible (before DirectX, a *heavier* version of OpenGL existed, but could 
+only be used on specialized machines). At the time, the real advantage of DirectX was its ability 
+to interface with the graphical display as well as the *human-machine interface* (keyboard, joystick, etc.) 
+or sound. Using DirectX means you only need one library to manage user interfaces!
+
+As you can see, DirectX is more than just a graphics API... In fact, DirectX is a set of multiple 
+libraries for gaming:
+
+- **Direct3D/2D** for the graphic rendering,
+- **Xaudio** (aka. DirectSound) for... sound,
+- **DirectPlay** for multiplayer session,
+- **Xinput** (aka DirectInput) for Human Interface Device (HID),
+- **DXGI** for hardware management like GPU card selection,
+- And others for specialized usage.
+
+At this time, DirectX is used for a mono-thread usage and all action taken inside user code, are 
+executed immediatly (no command list). Multi-threading will not be available until version 11 on 
+Windows Vista.
+
+Versions 11 and 12 essentially change the way resources are allocated in video memory and how GPU 
+instructions are processed by it.
+
+Since May 20, 2020, DirectX12 has been ported to linux as open source. This is particularly 
+interesting for the idea of porting my engine to other platforms. *I wasn't aware of this when I 
+chose this API, but it makes me all confident for the future.*
+
+DirectX is included as standard in the Windows SDK, which is installed with Visual Studio (as long 
+as you select **Game Development with C++** in the installation options). So let's move on to the next part...
+
+### VisualStudio setup
+
+I'm using *VisualStudio Community edition* for my game engine developement. It has all the tools you 
+need for design and debugging. Although it can be heavy to install, I can recommend to the purist 
+to install only the SDK with the MSVC toolchain, but I won't detail the procedure here (far too 
+long and technical for this post).
+
+For the setup options, the minimal is:
+
+- **Game Development with C++**,
+- Windows SDK (normally included by default),
+- HLSL tools,
+- Graphics tools (located in Windows *Optionals Features* in Apps settings).
+
+### Others usefull graphic debugging tools
+
+In addition to code design and debugging tools such as Visual Studio, I use graphical debugging 
+tools that are specifically designed to check the graphical pipeline.
+
+I recommend two of them, mainly because I'm used to using them, but they were the ones who got 
+me up quickly: 
+
+- **[PIX][link_pix]** is a precise measurement and tunning tools of render timing. Developed by 
+Microsoft, it come as a standalone program (for GUI) and a library to integrate into our code. 
+When our game start, the PIX program will connect to the [lib interface][link_pixlib] and begin to collect datas 
+about the current running graphic pipeline, getting all GPU resources and event timing on the move. 
+It can also be launch on a separate machine from the one where the game is run and connect to it 
+through network. It only work with Direct3D API.
+- **[RenderDoc][link_renderdoc]** is equivalent to PIX in terms of features but it's open source 
+and can have plugins and scripts to extends its limits. Unlike PIX, it support Direct3D, OpenGL 
+and Vulkan API. It plug on app using debug layer of the API (who need to be integrated by dev 
+in its code). Linux support is a plus!
+
+Both of this tools work better on Direct3D-12 API, with retro-compatibility to version 11.
+
+### Project template and others examples
+
+My main aim is to give you my experience of game engine development. I won't go into detail here 
+on how to create a new project in VisualStudio.
+
+With the DirectX suite integrated into the IDE, you'll have access to 4 template variants:
+
+- Direct3D-11 with or without Device Resource (DR),
+- Direct3D-12 with or without DR.
+
+DR handle the *boiler-plates* of Direct3D and DXGI instance. And it give some example of how basically 
+interface with your GPU card and render an *empty* scene on your screen. I recommand using this in first 
+time and after some tries, you can make your own implementation. Try, experiment, fail... That the **only** 
+good method to learn effectively!
+
+But if you're feeling a bit lost on VisualStudio, I'd advise you to go [here][link_msdx12quick] or [there][link_msdx12flow].
+
+
+
+[link_eclipse]:          https://www.eclipse.org/
+[link_vs]:               https://visualstudio.microsoft.com/
+[link_cmake]:            https://cmake.org/
+[link_pix]:              https://devblogs.microsoft.com/pix/download/
+[link_pixlib]:           https://www.nuget.org/packages/WinPixEventRuntime
+[link_renderdoc]:        https://github.com/baldurk/renderdoc
+[link_msdx12quick]:      https://learn.microsoft.com/en-us/windows/win32/direct3dgetstarted/building-your-first-directx-app
+[link_msdx12flow]:       https://learn.microsoft.com/en-us/windows/win32/direct3d12/creating-a-basic-direct3d-12-component