Window Creation & DirectX 12 Initialization

All good projects must start somewhere. Before we can begin working on portals, a window needs to be created, and DirectX 12 needs to be initialized. For this, I heavily utilized Jeremiah's tutorial on DirectX 12: https://www.3dgep.com/learning-directx-12-1/. This is the code so far. There is a lot of code here! With almost 800 lines of code, the final result!? (drum roll) 

Yes! A Window!

There is a lot moving components within DirectX 12 in order to initialize it. Way more than DirectX 11! In order to initialize DX12 we first we needed to get the adapter, then create a device, then create a command queue, then create a swap chain, then create a descriptor heap for retender target views, then create render target views, then create command allocator per back buffer, then create a command list, then create a fence... Phew! Once all of that is done we can finally run our game loop.

The render loop contains the most important logic in understanding how DX12 is being used. The render loop first clears the render target view with the clear color, executes the command list for the current back buffer, and presents the back buffer to the screen. The commands in DX12 are dispatched without blocking. Thus, it is possible we could keep calling the render function and return back at the same back buffer before the command list we populated in the previous call has been fully executed. To ensure that the previous commands in the command list are executed we use a fence. The fence is essentially an object that can be enqueued in the command queue. When the queue reaches that fence object, it will signal it. We can then wait on that signal with a Windows event. This a is a diagram of the render loop provided by Jeremiah:  
An example of performing GPU synchronization (Jeremiah)

This example shows a double-buffered implementation. For M back buffers, main, on frame N, would wait for fence value N - (M - 1). My implementation currently uses triple buffering but can be changed variably.

In addition to the window create and basic DX12 initialization, my window implementation currently supports variable refresh rate, and the ability to turn on and off vsync.

In the future, I will reorganize the code by encapsulating the window and DX12 in separate classes and files.  
   

Comments

Post a Comment

Popular posts from this blog

Enabling Raytracing - Part 2

Image
Code so Far Here is the code  for this section: Enabling Raytracing - Part 2 This week I added the shader binding table for raytracing. The shader binding table is where the data is bound to root parameters. This is contrary to rasterization where the parameters are bound through command list calls such as SetGraphicsRootConstantBufferView . One that was done I updated the render loop to support raytracing. This included transitioning the output buffer to unordered access, setting the pipeline state, and calling the DispatchRays method using the  D3D12_DISPATCH_RAYS_DESC which contains info about how many rays to generate, and the shader binding table. For my demo, one ray is generated for each pixel. After calling DispatchRays , our output image is written to. I then copy the image to the render target. The shaders were also updated to actually generate rays, and output the color of the cube. The RayGen shader was updated to call the TraceRay. The ClosestHit shader was ...
Read more

DXR Demo - Introduction

Welcome. I am a programming student at the Florida Interactive Entertainment Academy (FIEA) and this blog's aim is to chronicle my ten-week solo programming project during my final semester. The project at hand involves the implementation of raytracing, harnessing the power of DirectX 12 and DXR. DirectX 12, the latest DirectX API as of its introduction on July 28th, 2015, alongside Windows 10, allows for advanced low-level programming. It streamlines graphics programming by reducing driver overhead and enhances efficiency in multi-threading tasks. This level of control, however, comes with an increased responsibility for the graphics programmer to thoroughly understand and manage the complexities involved in getting a program operational. As a first-time user of DirectX 12, I anticipate a challenging yet rewarding journey ahead. In this blog, I aim to document the developmental milestones, challenges, and technical insights that arise during the creation process. Expect to see dee...
Read more

Simple Lighting

Image
Code so Far Here is the  code  for this section Rendering a Scene Now that I can render a scene, and have the raytracing pipeline setup, I want to make the raytracing scene look better. In rasterization there is diffuse light, specular lighting, etc., but how do you do proper shading for a ray tracer? To answer this question I picked up the book  Physically Based Rendering, Fourth Edition , by Matt Phar et al. This book goes in depth in the theory and implementation of how to achieve photorealistic renderers using raytracing. A critical understanding of how light actually works is necessary (at least at a macro level) in order to replicate its behavior. When a light source strikes an object it's light can either be reflected, refracted, or scattered in any direction due to subsurface scattering. The probability of each direction can be described by a probability distribution called bidirection scattering distribution function (BSDF).  Surface scattering example (Matt...
Read more