What’s New in the March 2016 Xbox One XDK
The March 2016 release of the Xbox One XDK from Microsoft contains the following new features, tools, and documentation. For features that shipped in a previous release of the Xbox One XDK, see the What’s New document for that release, available from Features Introduced in Previous Releases.
Sections:
Release Notes and Xbox One XDK Updates
The most recent release notes for and updates to the Xbox One XDK can always be found on Xbox One XDK Software Downloads on the Xbox Game Developer site. For access, log in with your ID and password on https://developer.microsoft.com/en-us/games/xbox/partner/index; at the top of the page, point to Development and click Downloads.
You can check with your account manager for the latest information about upcoming Xbox One XDK releases.
Xbox One XDK Version Info
The March 2016 Xbox One XDK contains the latest tools and libraries for Xbox One.
What’s new in the March 2016 XDK
Roadmap
The Xbox One Developer Roadmap on XGD has been updated with the latest projections of developer-facing feature work. The roadmap is intended to help developers plan their implementation schedules around upcoming feature and tooling efforts for the Xbox One console and related services.
Table of Contents
Graphics
Direct3D 12.x improvements
The following improvements and optimizations have been made to Direct3D 12.x in the Xbox One XDK:
- D3D12.x now supports shader limit controls through extensions to pipeline state objects (PSOs). You can use the D3D12XBOX_GRAPHICS_SHADER_LIMITS_DESC and D3D12XBOX_COMPUTE_SHADER_LIMITS_DESC structures to establish limits in conjunction with the CreateGraphicsPipelineStateX function and the new CreateComputePipelineStateX function. You can use the default limits initialization by calling the D3D12XboxInitializeDefaultGraphicsShaderLimits and D3D12XboxInitializeDefaultComputeShaderLimits functions.
- You can now derive compute PSOs from existing compute PSOs by calling the CreateDerivedComputePipelineStateX function. Derived compute PSOs provide a convenient way to modify shader limits.
- The SerializeComputePipelineStateX and DeserializeComputePipelineStateX functions have been added for advanced construction of compute PSOs. These functions operate on the new D3D12XBOX_SERIALIZE_COMPUTE_PIPELINE_STATE and D3D12XBOX_DESERIALIZE_COMPUTE_PIPELINE_STATE structures. The behavior of these new APIs is consistent with that of other graphics PSOs.
- The CopyResourceX and CopyTextureRegionX functions now support additional D3D12XBOX_COPY_FLAGS values. The new values support HTile resummarization, the decompression of regions within a texture, and copy-based decompression to layout-compatible (initially compressed) destinations.
High Dynamic Range and Wide Color Gamut support (Preview)
You can now enable High Dynamic Range and Wide Color Gamut by calling the Windows::Xbox::Graphics::Display::DisplayConfiguration::TrySetHdrModeAsync method, creating a swapchain with the DXGIX_SWAP_CHAIN_FLAG_COLORIMETRY_RGB_BT2020_ST2084 flag, and then presenting with the DXGIXPresentArray function.
Note This is a new feature in the Xbox One XDK. Please submit feedback for this feature on the Entertainment Developer Forum or at Xbox One Developer Feedback.
XHIT improvements
The following improvements have been made to the Xbox Hang Investigation Tool (XHIT):
- GPU crash analysis has been improved, and now provides a simplified summary of the crash analysis.
- Fence (wait-reg-mem) hang detection on the GPU and SDMA units has been improved.
- You can now assign names to D3D12.x fence objects and custom fence memory locations to help debug fence hangs.
PIX
Support for new Direct3D 12.x API extensions
PIX now supports the following new D3D12.x API extensions:
- Extensions for building your own command bundles.
- The DrawIndexedX API, which allows D3D12.x to group multiple draw calls. PIX groups these calls under a DrawIndexedXPerformanceGroup entry in the Events list.
- The ExecuteIndirectBundleX API, which allows you to pass a buffer of GPU packets to be executed. PIX shows the provided GPU commands as nodes under the ExecuteIndirectBundleX API call in the Events view. The complete set of packets passed to ExecuteIndirectBundleX can be inspected in the Command Disassembly view.
Improved user interface
The PIX user interface has been streamlined to make it easier to work with multiple captures at the same time. The performance of view editing has also been improved, which means that you can now rearrange your user interface much faster.
Decompression lane in GPU timeline
The GPU timeline now includes a new Decompression lane. This lane shows depth, color, and FMask decompresses, as well as fast clear eliminates and HTile resummarize actions across the frame.
Shader debugger improvements
Support for debugging tessellation and geometry shaders has been added. This feature is available when using the GPU Instructions debugging mode. PIX now provides better support for handling preprocessed HLSL shader files. If PIX cannot locate HLSL files due to preprocessor actions, you can add the files later and PIX will handle the files as if they were part of the capture.
Improved capture performance
Performance of the network communication between PIX and the development console have been optimized to handle capture at full gigabit speed.
D3D12.x timing capture improvements
Timing captures now display D3D12.x async compute work on the timeline and in the Events view. Command buffer predication for D3D12.x is now supported in timing captures.
Timing capture hierarchical graphs
Timing captures now support hierarchical display of the PIXBeginEvent, PIXEndEvent, and PIXSetMarker functions for all GPU lanes.
Improved support for Write64BitValueBottomOfPipeX
Calls to the Write64BitValueBottomOfPipeX API are now displayed on the GPU Capture timeline, regardless of which context these calls were made on.
New Memory Layout Visualization tab in CPU Instruction traces
Instruction traces now include a new Memory Layout Visualization tab that will help you optimize your cache line usage. This visualization organizes your memory into blocks and lets you drill down from larger block sizes to individual cache lines. Highlighting is provided to help you quickly drill down to the lines that are being used inefficiently. The set of functions, the source code for those functions, and the individual CPU instructions that touch each cache line are provided for all blocks of memory in the system.
Exclusion lists can now be provided for Function Summary and Callgraph captures
Instrumented CPU captures now take a list of functions to exclude from captures. By excluding specified functions, you can reduce the volume of data that you need to analyze and reduce the amount of overhead introduced by the profiler. For example, you could exclude functions that have already been fully optimized. You can also exclude small wrappers around existing functions that are called numerous times. You can create exclusion lists using the function selection dialog from the Settings page in PIX. These lists can be imported and exported to disk so that they you can share them.
Xbox Live
Tournaments
Tournament APIs are now available. For more information, see the API reference for the xbox::services::experimental::tournaments namespace in the Xbox Live documentation.
Throttling
Fine-grained throttling is being rolled out to most Xbox Live services. Xbox Service API (XSAPI) will automatically handle retries and inform you of calls that are throttled during development. For more information, see the “Best Practices Calling Xbox Live” topic in the Xbox Live documentation.
Leaderboards
You can now access multicolumn leaderboards by calling the GetLeaderboard function. If you provide a vector that contains the names of additional columns, the vector of columns in the result will be populated with data if those columns exist.
Fiddler updates
You can now use the Fiddler tool to debug Data Platform events and verify that they are being sent properly. This feature is available only for Universal Windows Platform (UWP) events.
Xbox Live documentation updates
The Xbox Live documentation now contains the following updates:
- Documentation for Application Insights is now available. You can use Application Insights with a free Microsoft Azure account to view Data Platform events in near-realtime. This functionality is currently available only for UWP applications running on Windows 10 on your development computer.
- Documentation for the Xbox Common Events Tool for UWP developers now explains how to generate wrappers for sending Data Platform events. This feature is optional—you can continue to use the WriteInGameEvent function if you prefer. For more information, see the “Game Events” topic in the Xbox Live documentation.
- Information about how to collect logs for the Live Trace Analyzer tool is now available. For more information, see the “Analyze calls to Xbox Live Services” topic in the Xbox Live documentation.