Hardware

DirectX Raytracing (DXR) Tier 1.1 New Features Can Work With Just Driver Support Without Heavy Hardware Modification

Ray Tracing is certainly a feature that gamers, especially with high-end graphics cards from NVIDIA and AMD, are eagerly waiting for. Leading makers of GPUs, which will soon include Intel as well, are actively building their hardware to support the feature which realistically renders the light and shadow effects based on the real-world laws of physics, and brings hyper-realistic and immersive visuals.

Meanwhile, Microsoft is ensuring the Windows OS ecosystem is well-suited as an ideal platform to play high-end games. The company’s DirectX platform, which has long been a leading standard for desktop gaming, is being tweaked to natively support and even boost the ‘Real-time Ray Tracing’. In fact, the DirectX Raytracing (DXR) Tier 1.1 is the latest standard that supports a set of new features. Some of the exciting features that real-time ray-tracing could support in the near feature include inline ray tracing, DispatchRays() calls via ExecuteIndirect(), Growing state objects via AddToStateObject(), GeometryIndex() in raytracing shaders, and more. Let’s look at some of the new features that DirectX 12 for Windows 10 will support for ray tracing.

Inline Ray Tracing:

An alternative form of ray tracing, inline ray tracing doesn’t use any separate dynamic shaders or shader tables. The API for the feature hides access to the acceleration structure (e.g. data structure traversal, box, triangle intersection). This essentially leaves it to the hardware/driver. Interestingly, all the necessary app code for handling both enumerated candidate hits and the result of a query (e.g. hit vs miss) can be self-contained in the shader driving the RayQuery.

Inline ray tracing offers developers the option to push for more ray tracing processes, as opposed to handing work scheduling entirely to the system. Needless to add, this optimization of processes is quite useful for developers who are jostling with multiple shadows. Moreover, the developers have complete freedom to dynamically switch to the inline form for simple recursive rays.

DispatchRays() Calls via ExecuteIndirect():

This feature enables shaders on the GPU to generate a list of DispatchRays() calls. These include individual parameters like thread counts, shader table settings and other root parameter settings. The best aspect of the feature is that the entire list can be executed without the process ever needing an intermediate round-trip back to the CPU.

All scenarios that prepare raytracing work on the GPU and then immediately spawn it, should immensely benefit from the feature. Needless to add, this feature should help a lot with several adaptive raytracing scenarios such as shader-based culling, sorting, classification, and refinement.

Growing State Objects via AddToStateObject():

An optimization feature, this new one attempts to reduce wasteful processing threads. Quite a few apps and processes today create a fully populated ray tracing pipeline, which wastes a lot of resources and burdens the system. Currently, the D3D12 runtime still parses the full state object being created out of building blocks.

Even though it is done to verify correctness, with AddToStateObject(), a new state object can be made by adding shaders to an existing shader state object. Needless to add, the CPU overhead will remain proportional only to the data being added.

GeometryIndex() In Ray Tracing Shaders:

This feature allows shaders to distinguish geometries within bottom level acceleration structures. Earlier, geometries could be distinguished by varying data in shader table records for each geometry, but with the new method, the app is freed from the burden. Moreover, if all geometries share the same shader, the app can choose to set the MultiplierForGeometryContributionToHitGroupIndex parameter to TraceRay() 0.

This will essentially ensure the geometry index no longer factors into the fixed-function shader table indexing calculation. Still, if needed or desired, the shaders can use GeometryIndex() to index into the app’s own data structures.

In addition to the aforementioned features, the DirectX Raytracing (DXR) Tier 1.1 also includes RAY_FLAG_SKIP_TRIANGLES and RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES flags. While these flags are available to individual raytracing calls, they can also be globally declared via raytracing pipeline configuration.

It is amply clear that Microsoft is trying to optimize DirectX 12 for graphics-intensive games. Moreover, with ray tracing promising to be one of the most important features for high-end games and gamers, the company is ensuring that the system, CPU, and GPU are optimally utilized with minimal redundancies.


Leave a Reply

Your email address will not be published.

Close