The swap chain stores no less than two buffers that are used to render the scene. The buffer that is currently being rendered to is called the back buffer and the buffer that is currently being presented is called the front buffer.
In previous versions of DirectX, the DXGI presentation model used a bit-block transfer bitblt model to present the rendered image to the display. When using a bitblt presentation model, the Direct3D runtime copied the contents of the front buffer to a Desktop Window Manager DWM redirection surface. Only after the contents of the front buffer were fully copied to the redirection surface was the image presented to the screen.
Windows 8 and DXGI 1. Using the flip presentation model, the Direct3D runtime passes the front buffer surface directly to the DWM for presentation to the screen. The flip presentation model provides a performance improvement in both space and speed since the redirection surface is no longer required and the front buffer does not need to be copied before it is presented to the screen.
The swap chain stores pointers to a number of buffers in GPU memory. After a present, the pointers are updated to swap through the buffer chain. The image above provides a visual example of the DXGI flip model [20]. DirectX 12 does not support the bitblt presentation model and only supports the flip presentation model. There are two flip effects that can be used when creating the swap chain [21] :. The discard means that if the previously presented frame is still in the queue to be presented, then that frame will be discarded and the next frame will be put directly to the front of the presentation queue.
Using this presentation model may cause presentation lag when there are no more buffers to utilize as the next back buffer the IDXGISwapChainPresent1 method will likely block the calling thread until a buffer can be made available. This code is similar to the the GetAdapter function shown earlier and is not described in detail here.
This method has the following signature [23] :. Switching to a full screen state will be handled manually using a full-screen borderless window. In the next sections, a descriptor heap is created and the views for each back buffer are recorded into the descriptors of the descriptor heap. A descriptor heap can be considered an array of resource views.
Certain types of resource views descriptors can be created in the same heap. Descriptor heaps will be discussed in more detail in another lesson which deals with binding textures to the rendering pipeline.
For now, a descriptor heap is created to store the render target views for the swap chain buffers. The CreateDescriptorHeap function described above is used to create a descriptor heap of a specific type. A render target view RTV describes a resource that can be attached to a bind slot of the output merger stage see Output Merger Stage. The render target view describes the resource that receives the final color computed by the pixel shader stage.
More complex usages of render targets will be discussed in the next lesson. For this lesson, the render target will only be cleared to a specific color. The first parameter to this method is the pointer to the resource that contains the render target texture.
A NULL description is used to create a default descriptor for the resource. Resource transitions will be discussed in more detail later in this lesson. In the next sections, the command allocator and command list is created. Command allocators and command lists are required to issue rendering commands to the GPU. A command allocator is the backing memory used by a command list. A command allocator is created using the ID3D12Device::CreateCommandAllocator method and must specify the type of command list the allocator will be used with.
The command allocator does not provide any functionality and can only be accessed indirectly through a command list. A command allocator can only be used by a single command list at a time but can be reused after the commands that were recorded into the command list have finished executing on the GPU. A command allocator can only be reset after the commands recorded in the command list have finished executing on the GPU.
The CreateCommandAllocator function is used to create the command allocator for the application. The CreateCommandAllocator function shown here only creates a single command allocator but this function will be used later to create multiple allocators for the demo.
This method has the following signature [25] :. A command list is used for recording commands that are executed on the GPU. Unlike previous versions of DirectX, execution of commands recorded into a command list are always deferred. That is, invoking draw or dispatch commands on a command list are not executed until the command list is sent to the command queue.
Unlike the command allocator, the command list can be reused immediately after it has been executed on the command queue. The only restriction is that the command list must be reset first before recording any new commands. The CreateCommandList function is used to create a command list for the application. This method has the following signature [26] :. Command lists are created in the recording state.
For consistency, the first operation that is performed on the command list in the render loop which will be shown later is a ID3D12GraphicsCommandList::Reset.
Before the command list can be reset, it must first be closed. The command list is closed on line so that it can be reset before recording commands in the render loop. Internally, a fence stores a single bit unsigned integer value. Pseudo-code for using a fence object was shown previously in the section titled GPU Synchronization.
As a rule-of-thumb, the fence object should be initialized with a value of zero and the fence value should only be allowed to increase. The fence is considered reached if it is equal to or greater than a specific fence value.
As previously explained when discussing GPU Synchronization , each thread or GPU queue should have at least one fence object and a corresponding fence value. The same fence object should not be signaled from more than one thread or GPU queue but more than one thread or queue can wait on the same fence to be signaled. This method has the following signature [27] :. An OS event handle is used to allow the CPU thread to wait until the fence has been signaled with a particular value.
In the next section, the OS event handle is created. If the fence has not yet been signaled with specific value, the CPU thread will need to block any further processing until the fence has been signaled with that value. The OS event handle is created using the CreateEvent function which has the following signature [28] :.
The Signal function is used to signal the fence from the GPU. It should be noted that when using the ID3D12CommandQueue::Signal method to signal a fence from the GPU, the fence is not signaled immediatly but is only signaled once the GPU command queue has reached that point during execution. Any commands that have been queued before the signal method was invoked must complete execution before the fence will be signaled.
The fence is signaled after all of the commands that have been queued on the command queue have finished executing. This method has the following signature [29] :. In the next section, a function to wait until the fence is signaled with a particular value is described. It is possible that the CPU thread will need to stall to wait for the GPU queue to finish executing commands that write to resources before being reused.
Any resources that are never used as a writeable target for example material textures do not need to be double buffered and do not require stalling the CPU thread before being reused as read-only resources in a shader. Writable resource such as render targets do need to be synchronized to protect the resource from being modified by multiple queues at the same time.
The function will wait for a duration specified by the duration parameter which by default has a duration of about million years. It is advisable to provide the correct fence value to wait on otherwise the end-user will be waiting a long time for the application to continue processing. The currently completed fence value is queried on line If the fence has not yet reached that value, an event object is registered with the fence and is in turn signaled once the fence has reached the specified value.
It is sometimes useful to wait until all previously executed commands have finished executing before doing something for example, resizing the swap chain buffers requires any references to the buffers to be released.
For this, the Flush function is used to ensure the GPU has finished processing all commands before continuing. The Flush function is used to ensure that any commands previously executed on the GPU have finished executing before the CPU thread is allowed to continue processing.
On line , the fence is signaled on the GPU. The Signal function returns the fence value to wait for. The WaitForFenceValue function is used to wait for the fence to be signaled with a specified value. The Flush function will block the calling thread until the fence value has been reached. After this function returns, it is safe to release any resources that were referenced by the GPU. For this lesson, the Update function is extremely simple.
Its only purpose is to display the frame-rate each second in the debug output in Visual Studio. The frameCounter variable is used to keep track of the number of times the a frame was rendered to the screen since the last time the frame-rate was printed. The elapsedSeconds variable stores the time in seconds since the last time the frame-rate was printed. The t0 variable is the initial point in time and is initialized to the current time. Each frame, the frameCounter variable is incremented and the delta time is computed on line On line , t0 is updated with the current time point to prepare it for the next frame.
The frame-rate is printed to the debug output in Visual Studio only once per second. If the total elapsed time exceeds one second, then the frame-rate in frames-per-second is computed on line and on line , it is printed to the debug output. In order to compute the frame-rate for the next second, the frameCounter and elapsedSeconds variables are reset to 0.
Although this is a simple update function, it demonstrates how to create a simple game loop. In DirectX 12, it is the responsibility of the graphics programmer to ensure that resources are in the correct state before using them. Resources must be transitioned from one state to another using a resource barrier and inserting that resource barrier into the command list.
For this lesson, only transition resource barriers are used. In a later lesson more complex usages of resource barriers will be shown. Before any commands can be recorded into the command list, the command allocator and command list needs to be reset to its initial state. On lines , pointers to the command allocator and back buffer resource are retrieved according to the current back buffer index.
On lines the command allocator and command list are reset. This prepares the command list for recording the next frame. By default, this will transition all subresources to the same state. The resource transition must specify both the before and after states of the sub resource. This implies that the before state of the resource must be known. The state of the resource cannot be queried from the resource itself which implies that the application developer must track the last know state of the resource.
In a single-threaded application, tracking the last known state of the resource is relatively easy task but if the state of the resource needs to be tracked across multiple parallel threads, then it can get complicated. Methods to track the state of resources will be investigated in another lesson. In this lesson, the before and after states of the resource are known so they are hard-coded in the transition barrier structures.
If there is more than a single resource barrier to insert into the command list, it is recommended to store all barriers in a list and execute them all at the same time before an operation that requires the resource to be in a particular state is executed.
In this case, there is only one barrier. To clear the back buffer, a CPU descriptor handle to a render target view is stored in the rtv variable. The handle is offset from the beginning of the descriptor heap based on the current back buffer index and the size of the descriptor. The last operation performed during rendering is presenting the rendered image to the screen. After transitioning to the correct state, the command list that contains the resource transition barrier must be executed on the command queue.
This method must be called on the command list before being executed on the command queue. The command list is executed on the command queue using the ID3D12CommandQueue::ExecuteCommandLists method which takes a list of command lists to be executed.
Tough to answer I'll try anyway! Thing is though, it all depends on how much time you spend on it. It takes a touch of genius -- and a lot of courage -- to move in the opposite direction. My blog. AlbertoT The game engine is basically a collection of functions such as: move , animate ,.. Once you are familiar with the engine you can use these functions and structures same as you normally use , say, printf , rand etc.
At a professional level it is an other matter. BattleGuard This topic is closed to new replies. Nagle So what's going on with the "Metaverse"?
GDNet Lounge. There are plenty of useful tutorials and books out there, but they often use the legacy DirectX SDK and make use of a lot of deprecated support code. Since DirectX Tool Kit is open source, you can easily explore it to learn what it is doing. It is also specifically designed to be very modular so you can replace portions of it as you learn different aspects of the Direct3D graphics pipeline, HLSL shader programming, dynamic vs.
In terms of background material, there are numerous introductory books for graphics programming. They will cover the key topics of transformation math and view systems, texturing and rasterization, and other key concepts. See this post for the specifics. Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. Much of the code you will find in the examples assumes you understand these forms of mathematics and their common rules.
Understand the foundations of graphics and graphics technology, particularly 3D graphics. While DirectX itself has its own terminology, it still builds upon a well-established understanding of general 3D graphics principles. Understand the concept of a message loop, because you'll be implementing a loop that listens to the Windows operating system. And we're off! Ready to start? Let's review before we head on.
You have: An updated and working installation of Windows 8.
0コメント