Quote: "DX10 just has Geometry shaders, nothing else"
??
----------------------------------------------
DX10 has:
* The ability to process entire primitives in the new geometry-shader stage.
The ability to output pipeline-generated vertex data to memory using the stream-output stage.
Organization of pipeline state into 5 immutable state objects, enabling fast configuration of the pipeline.
Organization of shader constants into constant buffers, minimizing bandwidth overhead for supplying shader-constant data.
The ability to perform per-primitive material swapping and setup using a geometry shader.
New resource types (including texture arrays that can be indexed from shaders) and resource formats.
Increased generalization of resource access using a view.
Legacy hardware capability bits (caps) have been removed in favor of a rich set of guaranteed functionality, which targets Direct3D 10-class hardware (minimum).
Layered Runtime - The Direct3D 10 API is constructed with layers, starting with the basic functionality at the core and building optional and developer-assist functionality (debug, etc.) in outer layers.
Full HLSL integration - All Direct3D 10 shaders are written in HLSL and implemented with the common-shader core.
An increase in the number of render targets, textures, and samplers. There is also no shader length limit.
Integer and bitwise shader operations.
Readback of a depth/stencil surface or a multisampled resource, once it is no longer bound as a render target.
Multisampled alpha-to-coverage support.
---------------------------------------------
The removing of the legacy hardware caps alone is a blessing in itself. Also like the idea of dropping the fixed function vertex pipeline for full on HLSL integration. I would luv to see what would happen by letting Green Gandalf loose on this stuff!
Quote: "I wonder if it would be different if DX10 was XP compatible?"
Ofcoarse, obviously DirectX programming would have had an easier transition to DX10 programming from DX9 programming as it was for DX8 -> DX9 and DX7 -> DX8, etc... ie: people still like XP over Vista and will use it for years to come. So, there isnt any logical sense, IMHO, to not have DX10 supported on XP. Heck, the first version of DX10 was proven to be able to work on XP... Microsoft made sure that wouldn't happen again. I agree, making DX10 to work on Vista OS's and up was foolish. I hate that very fact about it. But, with the inclusion of geometry shader tech itself, I am still very interested in programming for it( hadn't yet ).
DX11, well, I would like to have the opportunity to catch up and see what possibilities I can do with DX10 on both vista and windows 7 before I even think about DX11( ofcoarse, that is just what I say for now... )...
------------------------------------------------------------
March 2009 Win7/DX11 Tech Preview:
[b]What's New in the March 2009 Windows 7/Direct3D 11 Technical Preview:[/b]
This version of the Windows 7/Direct3D 11 Technical Preview ships as part of the DirectX SDK and contains the following new features, tools, and documentation.
[b]Technical Preview of Direct2D [/b]
Direct2D is a hardware-accelerated, immediate-mode, 2-D graphics API that provides high performance and high quality rendering for 2-D geometry, bitmaps, and text. The Direct2D API is designed to interoperate well with Direct3D and GDI. This technical preview allows developers to evaluate the API and write simple applications, with some of the more advanced functionality possible on properly configured machines.
Documentation and samples for Direct2D are currently available on MSDN.
[b]Technical Preview of DirectWrite[/b]
DirectWrite provides support for high-quality text rendering, resolution-independent outline fonts, and full Unicode text and layout support, and much, much more.
A device-independent text layout system that improves text readability in documents and in UI.
High-quality, sub-pixel, ClearType text rendering that can use GDI Direct3D, Direct2D, or application-specific rendering technology.
Support for multi-format text.
Support for the advanced typography features of OpenType fonts.
Support for the layout and rendering of text in all languages supported by Windows.
This technical preview allows developers to evaluate the API and write basic applications for demonstration purposes only.
Documentation and samples for DirectWrite are currently available on MSDN.
[b]Technical Preview of DXGI 1.1 [/b]
DXGI 1.1 builds on DXGI 1.0 and will be available on both Windows Vista and Windows 7. DXGI 1.1 adds several new features:
Direct3D 10.1 Command-based Remoting. This is an enhancement to how Direct3D 10.1 (and Direct3D 10.1 based Direct2D) applications can optimize for the remoted display experience. Applications that want to customize for the remote display experience on rich remote clients (and with, but not necessarily) headless server configurations can choose to leverage Direct3D 10.1 Command Remoting which will transmit DXGI and Direct3D 10.1 APIs across the network rather than rendered bitmaps. Direct2D, based on Direct3D10.1, uses this mechanism of remoting by default, unless otherwise indicated.
Synchronized Shared Surfaces Support. This enables efficient read and write surface sharing between multiple D3D (could be between D3D10 and D3D11) devices.
BGRA format support. This allows GDI to render to the same DXGI surface targeted by a Direct2D, Direct3D 10.1 or Direct3D 11 device.
Maximum Frame Latency. Using IDXGIDevice1::SetMaximumFrameLatency and IDXGIDevice1::GetMaximumFrameLatency, titles can control the number of frames that are allowed to be stored in a queue, before submission for rendering. Latency is often used to control how the CPU chooses between responding to user input and frames that are in the render queue.
Adapter Enumeration. Using IDXGIFactory1::EnumAdapters1, titles can enumerates local adapters without any monitors or outputs attached, as well as adapters with outputs attached.
[b]Updated Samples [/b]
This release has several new and updated samples.
The new AdaptiveTessellationCS40 is an illustration of more advanced compute shader processing techniques that can be run on a D3D10 or D3D11 GPU.
The HDRToneMappingCS11 sample has been expanded to implement blur and bloom effects (in addition to tone mapping) using compute shader, as well as providing pixel shader implementations for comparison.
The MultithreadedRendering11 sample has been significantly updated, with more complex art assets and more intensive per-thread processing.
The SubD11 sample has been updated with a new facial model, and the sample now leverages the adjacency computation feature of the Samples Content Exporter.
-----------------------------------------
November 2008 DX11 Tech Preview:
[b]What's New in the November 2008 Direct3D 11 Technical Preview[/b]
This version of the Direct3D 11 Technical Preview contains the following new features, tools, and documentation.
[b]Tessellation [/b]
Direct3D 11 provides additional pipeline stages to support real-time tessellation of high order primitives. With extensively programmable capabilities, this feature allows many different methods for evaluating high-order surfaces, including subdivision surfaces using approximation techniques, Bezier patches, adaptive tessellation, and displacement mapping. This feature will only be available on Direct3D 11-class hardware, so in order to evaluate this feature you will need to use the Reference Rasterizer. For a demo of tessellation in action, check out the SubD11 sample available through the Sample Browser.
[b]Compute Shader [/b]
The Compute Shader is an additional stage independent of the Direct3D 11 pipeline that enables general purpose computing on the GPU. In addition to all shader features provided by the unified shader core, the Compute Shader also supports scattered reads and writes to resources through Unordered Access Views, a shared memory pool within a group of executing threads, synchronization primitives, atomic operators, and many other advanced data-parallel features. A variant of the Direct3D 11 Compute Shader has been enabled in this release that can operate on Direct3D 10-class hardware. It is therefore possible to develop Compute Shaders on actual hardware, but an updated driver is required. The full functionality of the Direct3D 11 Compute Shader is intended for support of Direct3D 11-class hardware, so in order to evaluate the full functionality you will need to use the Reference Rasterizer until such hardware is available. For a demo of the Compute Shader in action, check out the HDRToneMappingCS11 sample available through the Sample Browser.
[b]Multithreaded Rendering [/b]
The key API difference from Direct3D 10 in Direct3D 11 is the addition of deferred contexts, which enables scalable execution of Direct3D commands distributed over multiple cores. A Deferred Context captures and assembles actions like state changes and draw submissions that can be executed on the actual device at a later time. By utilizing Deferred Contexts on multiple threads, an application can distribute the CPU overhead needed in the Direct3D11 runtime and the driver to multiple cores, enabling better use of an end-user's machine configuration. This feature is available for use on current Direct3D 10 hardware as well as the reference rasterizer. For a demonstration of API usage, check out the MultithreadedRendering11 sample available through the Sample Browser.
[b]Dynamic Shader Linkage [/b]
In order to address the combinatorial explosion problem seen in specializing shaders for performance, Direct3D 11 introduces a limited form of runtime shader linkage that allows for near-optimal shader specialization during execution of an application. This is achieved by specifying the implementations of specific functions in shader code when the shader is assigned to the pipeline, allowing the driver to inline native shader instructions quickly rather than forcing the driver to recompile the intermediate language into native instructions with the new configuration. Shader development is exposed through the introduction of classes and interfaces to HLSL. For a demonstration, check out the Dynamic Shader Linkage 11 sample available through the Sample Browser.
[b]Windows Advanced Rasterizer (WARP) [/b]
Available in this SDK through Direct3D 11 and eventually also through Direct3D 10.1, WARP is a fast, multi-core scaling rasterizer that is fully Direct3D 10.1 compliant. Utilizing this technology is as simple as passing the D3D_DRIVER_TYPE_WARP flag in your device creation.
[b]Direct3D 10 and Direct3D 11 on Direct3D 9 Hardware (D3D10 Level 9) [/b]
Available in this SDK through Direct3D 11 and eventually also through Direct3D 10.1, the Direct3D API can target most Direct3D 9 hardware as well as Direct3D 10, Direct3D 10.1 and Direct3D 11 hardware. This is achieved by providing the Feature Level mechanism, which groups hardware into six categories depending on functionality: 9_1, 9_2, 9_3, 10_0, 10_1 and 11_0. A card only meets a feature level if it is fully compliant to that level, and each level is a strict super-set of those below it. Functionality is minimally emulated to assure no unexpected performance cliffs are encountered. Thus, features like Geometry Shaders are not available for Direct3D 9 level targets.
[b]Runtime Binaries [/b]
All runtime binaries provided in the Direct3D 11 tech preview that will be available on Windows 7 and Windows Vista SP1 are installed with the SDK and are labeled as "Beta" components (i.e. D3D11_beta.DLL). All beta-labeled components are time-bombed. To create projects to evaluate these new components, you must link to their equivalent beta-labeled import libraries (i.e. D3D11_beta.lib). If you have a PDC copy of Windows 7, the headers, libs, and pdbs provided in the Windows SDK with the build are appropriate for development using the Direct3D 11 components providing in Windows 7. Please reserve the use of the headers, libs, and pdbs in this SDK to the beta components provided herein.
[b]D3DX11 [/b]
D3DX11 currently supports texture loading, shader compilation, data loading and worker thread functions for Direct3D 11 resources. In the future, this component will provide more of the technologies available in D3DX10. Shader compilation functionality is also provided directly through the Direct3D Compiler component, described next.
[b]HLSL and Direct3D Compiler [/b]
The HLSL compiler has several new features for supporting the new technologies available in Direct3D 11. This includes object oriented programming through interfaces and classes, a direct indexing syntax for resource loads, and the 'precise' keyword for ensuring that all operations performed with a specific variable adhere to the strict floating point rules. Almost all new linguistic features have valid functionality on existing shader targets. In addition to supporting all Direct3D 9, Direct3D 10, Direct3D 10.1, and Direct3D 11 shaders the HLSL compiler also supports the special targets needed to write shaders for Direct3D 10 Level 9 targets. The D3D Compiler is now directly accessible outside of D3DX10 and D3DX11 through D3DCompiler.H and D3DCompiler.lib. With these new files, an application is not required to link to D3DX in order to perform runtime compilation, and an application is not required to include the compiler if only D3DX functionality is needed.
[b]D3D11 Reference Rasterizer [/b]
The Reference Rasterizer provides a gold-standard rasterization implementation for evaluation of Direct3D 11 features not yet available in hardware. The Reference Rasterizer is also provided as a way to verify a specific hardware implementation's accuracy to the rasterization standard. The reference rasterizer is designed for correctness, not performance. To create a reference device, simply pass the D3D_DRIVER_TYPE_REFERENCE flag at device creation.
[b]D3D11 SDK Layers [/b]
Direct3D11 SDK Layers provide a mechanism for tracking the operation of the Direct3D 11 runtime during development. Currently this is used for providing useful debug information, which not only includes errors on improper use but also warnings that recommend best practice use of the runtime and often provides in-depth, useful information for debugging. It is highly recommended that the debug output from D3D11 SDK Layers is turned on at all times during development and an application generates no debug output during execution before it is released or used with PIX for Windows for profiling. Enabling the debug layer is as simple as passing the D3D11_CREATE_DEVICE_DEBUG flag at device creation time. Developers are strongly encouraged to use layers in debug builds. Layers are not recommended for use in profile or release builds.
[b]New Samples [/b]
This release has four new samples.
The Dynamic Shader Linkage 11 sample demonstrates use of Shader Model 5 shader interfaces and Direct3D 11 support for linking shader interface methods at runtime.
The HDRToneMappingCS11 sample demonstrates how to setup and run the Compute Shader(CS for short later on), which is one of the most exciting new features of Direct3D 11. Although the sample only utilizes the CS to implement HDR tone-mapping, the concept should extend easily to other post-processing algorithms as well as more general calculations.
The MultithreadedRendering11 sample demonstrates how to split rendering among multiple threads, with very low overhead.
The new SubD11 sample is very similar to the SubD10 sample in the DirectX SDK, except that it has been enhanced to take advantage of three new Direct3D 11 pipeline stages: the hull shader, the tessellator, and the domain shader.
-----
Edit: Put that info in the code blocks to shorten the post... format is harder to read... ah well...
