An article about DirectX 10

Microsoft's DirectX 10 represents the greatest progress in 3D APIs since the advent of programmable shader. With a variety of re-engineering, DirectX 10 presents a series of very eye-catching new features, including highly optimized runtime, powerful geometry shader, texture array, and so on, these features will bring PC real-time 3D graphics into a new world.

A Brief History of DirectX Development

In the past decade,DirectXIt has steadily become the preferred API for game development on Microsoft Windows. Each generation of DirectX provides support for new graphics hardware features, so it can help game developers take an amazing step every time.

Microsoft DirectX API (Application Programming Interface: Application Interface) was first released in 1995, it is designed to provide software developers on the Windows platform with a simpler standard interface for multimedia and game application programming.

When DirectX was introduced, developers must perform audio, video, and other operations based on hardware.-Of course, OpenGL-based operations can reduce the workload in a large program, but OpenGL is obviously far from enough support. -- However, there are many different types of video cards and sound cards. It is a nightmare to write a game that can run on all platforms.

DirectX provides a complete set of Multimedia Interface solutions by providing a series of APIS for multimedia applications, such as 2D and 3D applications, audio, and input devices, this allows developers to write corresponding software programs based on APIs without having to consider specific hardware. The hardware difference is insignificant and programmers can develop various multimedia and game software more efficiently.

Of course, the development of DirectX is not smooth, and the initial version is far from stable.

Version	Operating System	Release Date
DirectX 1, 1.0	Windows 95a	9/30/95
DirectX 2.0/2.0a	Windows 95osr2/NT4.0	6/5/96
DirectX 3.0/3.0a	Windows NT 4.0 sp3	9/15/96
DirectX 1, 4.0		Unpublished
DirectX 1, 5.0	Windows NT 4.0/beta for NT 5.0	7/16/97
DirectX 1, 5.1	Windows 95/98/NT4.0	12/1/97
DirectX 1, 5.2	Windows 95	5/5/98
DirectX 1, 6.0	Windows 98/NT4.0	8/7/98
DirectX 1, 6.1	Windows 95/98/98SE	2/3/99
DirectX 1, 7.0	Windows 95/98/98SE/2000	9/22/99
DirectX 7.0a	Windows 95/98/98SE/2000	9/99
DirectX 1, 7.1	Windows 95/98/98SE/ME/2000	9/16/99
DirectX 8.0/8.0a	Windows 95/98/98SE/ME/2000	9/30/2000
DirectX 1, 8.1	Windows 95/98/98SE/ME/2000/XP	11/12/01
DirectX 9 Shader Model 2.0	Windows 95/98/98SE/ME/2000/XP	12/19/2002
DirectX 9 Shader Model 2.0b	Windows 98/98 SE/ME/2000/XP	8/13/2003
DirectX 9 Shader Model 3.0	Windows 98/98 SE/ME/2000/XP	8/9/2004

Development of DirectX 3D

The specific DirectX API used in 3D graphics in DirectX is direct3d, which is also the most important part of DirectX. However, DirectX 3D is widely used after DirectX 6.0:

　　DirectX 1, 6.0: Added technologies such as bilinear filtering and tri-linear filtering to optimize 3D image quality, and added environment shot concave and convex textures to make 3D Game images more realistic.

　　DirectX 1, 7.0: T & L is supported, and the Chinese name is "coordinate conversion and light source". The conversion of coordinates and lights in 3D games is transferred from the CPU to the GPU, the performance is improved by 20% compared with dx6.1. This also makes NVIDIA geforce 256 and ATI radeon 256 brilliant, so that 3dfx completely out of the market competition.

　　DirectX 7.0a: Improves the performance and compatibility of game control devices.

　　DirectX 1, 7.1: Released together with Windows Millennium.

　　DirectX 8.0/8.0a: Supports Shader Model 1.0 and 1.1, and introduces the concept of programmable pixel shaders and vertex shaders in the graphics card, which are also applied to Xbox consoles. Compared with hardware T & L's fixed light and shadow conversion, Vs and PS units are more flexible, making GPU a programmable processor.

　　DirectX 1, 8.1: Pixel shader is upgraded to version 1.2, 1.3, and 1.4. It supports up to 28 commands per clock. Version 1.4 is only supported by ATI radeon 8500 graphics card.

　　DirectX 9.0 Shader Model 2.0: The shader of sm2.0 has higher performance. It supports the pixel shader length of up to 96 commands, and also greatly improves directplay and some audio.

　　DirectX 9.0 pixel shader 2.0b: ATI radeon x600/700/800 series graphics cards are first adopted, starting to support more commands (up to 1536) and more temporary registers (32 compared to the previous 12 ), the new facing register and geometry instancing are also supported.

　　DirectX 9.0 Shader Model 3.0: Supports more commands and the traffic control and dynamic branches of commands, so that programmers can add loop operations in shaders, making programming easier. For the first time, it was used by geforce 6800 graphics cards.

From the development history of DirectX, we can see that Microsoft's 3D API and hardware are developing together, new hardware brings new DX features, and new DX features accelerate the development of hardware. In directx10, it is also a new realm of 3D graphics development.

Advantages of DirectX 10 Architecture

DirectX is popular among developers because of its ease-of-use and rich features. However, DirectX has been plagued by a major problem, that is, high CPU load.

Before the appearance of the Graphic programming API, the 3D application directly sends commands to the graphic hardware to complete the drawing. Although the development work is heavy, the hardware efficiency can be guaranteed to a great extent.

Graphics APIs, such as DirectX and OpenGL, are built between the graphics hardware and applications. In this way, applications can use unified Graphic programming code to perform operations on underlying hardware, saving programmers from the nightmare of interacting with a large number of graphic hardware. However, this also results in that every time DirectX receives a command from the application, it must first analyze and process the command, and then send the corresponding hardware command to the graphic hardware. Because the analysis and processing process is completed by the CPU, every 3D drawing command will bring the CPU load.

From a technical point of view, this CPU load has two negative effects on 3D images: First, it limits the number of objects that can be drawn simultaneously on the screen; secondly, limits the number of independent special effects that can be used in a scenario. This makes the number of details in the game picture very limited, and the main requirement of the image to have a sense of reality is rich details.

The main advantage of DirectX 10 is that it minimizes the CPU load, mainly through three ways to achieve this goal: first, modify the API core, this reduces the consumption of rendering objects and switching material effects to improve the drawing efficiency. Second, a new mechanism is introduced to reduce the CPU dependence of graphic operations, more operations are completed in the GPU. Third, a large number of objects can be drawn in batches by calling a single DirectX draw command.

Let's take a closer look at these three methods:

　　Improve drawing efficiency

In DirectX 10, the verification process of 3D data and drawing commands in the previous DirectX version was greatly modified. The so-called 3D data and Command verification refers to the inspection of the format and data integrity of the graphic data and drawing commands sent to the DirectX before drawing the image, to ensure that they will not cause hardware problems when delivered to the graphic hardware; this is a necessary step, but unfortunately this will bring a lot of performance overhead.

From the above table, we can easily see that in DirectX 9, each time before a frame is drawn, the relevant data to be used will be verified. In DirectX 10, the verification is performed only once after the data is created. This can obviously greatly improve the efficiency of the game.

Reduce the CPU dependency of graphic operations

To reduce the CPU dependency of graphics operations, DirectX 10 introduces three important mechanisms: texture arrays and predicated draw) and stream output (stream out ). Don't be intimidated by these three obscure terms. They are actually three mechanisms that are hard to understand.

　　Texture Array

The traditional DirectX switch operation in multiple textures puts a lot of pressure on the CPU, because each switch requires a call to the DirectX API function. Every time you draw an object that uses a new texture, You need to perform this switching operation. Sometimes, to achieve special material effects, you may need to switch the texture of an object several times, high overhead.

Therefore, in the past, many small textures were often combined into a large texture. By allocating different parts of the large texture to different 3D objects, in order to reduce texture switching and improve game operation efficiency. This method is quite complex, and the size limit of the texture in DirectX 9 is 4048 × 4048 pixels. That is to say, to accommodate more small texture blocks, you may have to load many such large textures.

The new texture array mechanism introduced by DirectX 10 will allow 512 individual textures to be accommodated in an array maintained by the graphics card, and, in the shader program, you can use a new command to obtain any texture in the array. This type of shader command runs on the GPU. In this way, the texture switching that originally consumed a lot of CPU time is easily transferred to the GPU. Because the texture is usually directly stored in the video memory, in this way, it is more efficient to work with the GPU that is located on the video card together with the video memory. Today, in DirectX 10, you only need to set the texture in the texture array at the beginning and specify a texture index number for each object to be drawn, and transfer the object 3D data together to the shader, you can rest assured that the GPU can select the texture for the object.

　　Draw Prediction

In general 3D scenarios, many objects are completely blocked by other objects. At this time, if you want the video card to draw these objects is in vain. Although advanced GPUs can pre-Remove blocked pixels (note that pixels) in the scene through hardware algorithms, there are still many unnecessary operations. For example, a complex role model that is completely blocked may have thousands of vertices on its body and requires complex skeleton skin animation and vertex illumination operations. However, after processing these vertices, the GPU starts to determine whether each pixel needs to be painted only when the role model is painted in pixels or pixels, when all pixels are removed, the previous vertex processing will be all in vain. Drawing predictions in DirectX 10 is the solution to this situation. In short, drawing and prediction: You can use a simple object that represents a complex object to determine whether the object is completely blocked. For example, you can use a large box that can cover the previous role, when drawing this box, if you find that all pixels are blocked, that is to say, this box must be completely invisible, then, you do not have to perform operations such as creating a skeleton skin. A box has at most eight vertices, which is much less overhead than processing thousands of vertices.

In addition, some real operations in the previous step also need to be completed by the CPU. in DirectX 10, it has been completely done by the GPU, which can also reduce the CPU pressure to a certain extent.
Data Stream output

Streaming data output is also an important feature of DirectX 10. It allows vertex shader or geometry shader on the GPU to add data to the video memory, which is impossible in the previous vertex shader.

In earlier DirectX versions, vertex shader can only read existing vertex data in the video memory. in DirectX 10, the new geometry shader, not only can the vertex data and geometric (point, line segment, triangle) data in the video memory be read, but new geometric data can be generated and stored back.

Batch drawing

In DirectX 9, the management of rendering status has always been very dependent on the CPU computing capability. The so-called rendering status refers to the various data and parameters that need to be set when the video card is used for a drawing operation. For example, to draw a character role, you must first set the data format, texture filtering mode, and semi-transparent hybrid mode of the geometric model data, all call the DirectX API once, which takes a lot of CPU time and greatly limits the rendering performance.

To enable these operations in batches, DirectX 10 introduces two new structures: State object and constant buffers ).

The State object refers to the previous scattered state according to the function into a few items. In this way, when you want to set a series of related states, you do not need to call the DirectX API for each State, you only need to set all these statuses to the video card once.

Constant buffering is another very meaningful mechanism. Rendering State settings are only a small part of the preparation before the model is drawn. To draw a character role, the color, position, type, range, and so on of the person's light source must be set to the video card in advance. In order to drive his skin through bones, you also need to set the position information of the skeleton, and these things are mainly transmitted to it through the constant registers in the GPU. Each constant register can store a four-dimensional floating point vector (that is, four floating point numbers ). Constant registers are an important way for a game program to input data into a GPU in a game scenario.

In DirectX 9, the number of such constant registers is very limited, and each time you update a register, you need to call the DirectX API function once. By using the constant Buffer structure, DirectX 10 can accommodate 4096 constants in each constant buffer, and a large number of constants can be updated by calling an API only once.

For example, in the previous DirectX version, if the program wants to draw many trees and weeds in the scenario, it can adopt a method similar to "clone: first, make a three-dimensional model of one or more trees and grasses. Then, when you draw a frame, you will not stop at different positions and directions and use different sizes as parameters, by calling the DirectX API's rendering function to draw these models, you can draw a lot of vegetation. However, every time you draw a tree, you have to set a lot of parameters and call the API once. This is very time-consuming, so in the past, there were few large-scale and detailed forest scenarios.

In DirectX 10, we can first set several models of trees and grass to the graphics card, and then write the positions, directions, and sizes of all trees to be painted into the constant buffer at a time, in this way, the video card will draw all the trees and grass together.

In short, DirectX 10 helps increase the gaming performance and efficiency to a new level through mechanisms such as advance data verification, texture arrays, rendering prediction, streaming output, State objects, and constant buffering. In this way, It also avoids the problem that the previous DirectX version could not perform more detail Optimization on the graphics due to excessive CPU load.

Shader Model 4.0

Another notable feature of DirectX 10 is the introduction of Shader Model 4.0. What new features can the Shader Model 4.0 bring, especially when comparing it with the Shader Model 3.0 in DirectX 9.0c?

　　Introduce the new shader: geometry shader

The new geometry shader introduced by DirectX 10 can be used to program and manipulate geometric elements. At the same time, vertex, geometry, and pixel shader adopt a unified sahder architecture.

Geometry shaders is a major improvement in the programmable graphics pipeline. It allows the GPU to dynamically generate and destroy geometric map metadata for the first time. Using the new data stream output function together, many previously unfeasible algorithms can now be used in the GPU.

　　Unified shader Architecture

In DirectX 9, pixel shader always lags behind vertex shaders in various aspects, including the number of constant registers, number of available commands, and shader length. Programmers need to treat these two types of shader separately.

In Shader Model 4, regardless of vertex, geometry, and pixel shader, there is a unified instruction set and the same number of temporary/constant registers. They share all available resources in the GPU equally. In this way, you do not have to consider the limitations of each type of shader during programming.

　　Hundreds of times more available resources than DirectX 9

The available resources in the shader are greatly expanded in the Shader Model 4.0. Just as early programmers have racked their brains to use a poor K memory, programmers need to carefully allocate valuable shader register resources when using the previous DirectX game development process. The number of registers directly affects the complexity of the shader program. This is the same principle as writing large-scale software such as Microsoft Office on a K memory machine.

In DirectX 10, temporary registers are extended from 32 to 4096, and constant registers are extended from 256 to 65536.

　　More rendering targets)

The so-called rendering target refers to the target that the GPU can draw the screen, and we can understand it as a GPU canvas. In general, the rendering target is output to the screen, so that we can see the picture. However, sometimes some rendering results are not directly painted to the screen, but are returned to the GPU for further special effect processing. In addition, the rendering target is not necessarily the color information of the picture.

Based on the needs of graphic effects, the rendering target may be the distance from each object to the screen, the direction of each pixel on the object surface, or the temperature of each object surface, you can draw any information as needed. To improve the efficiency in this case, many new graphics cards support drawing different information into different rendering targets after the same shader is executed. This mechanism is already supported in DirectX 9, but it imposes a maximum of four rendering targets at the same time. DirectX 10 doubles the number.

More textures

Support for texture arrays (texture arrays) is provided in Shader Model 4.0. In the previous sections, we have provided a detailed introduction to texture arrays. Here we will only focus on the shader-related sections.

A maximum of 512 textures of the same size can be saved in each texture array. In addition, the resolution of each texture is extended to 8192x8192. A larger resolution means more details in the texture. The number of textures that can be accessed simultaneously in a shader is increased to 128. That is to say, each time you run the same shader, you can use 512 of the 128 textures of a texture array. Therefore, in DirectX 10, the texture diversity and details will be greatly improved.

　　New HDR color format

The most popular concept in the real-time graphics industry over the years should be HDR. It uses a floating-point color format to provide a great deal of precision and color range for texture and illumination calculations (the previous textures generally use an integer color format ). Although the last display on the screen is still an integer of 8 bits per color channel, in the past, due to texture and illumination calculation, the 8 bits per channel were used for calculation, therefore, before the screen is displayed, many details are lost in Low-precision operations.

The use of a 16-bit floating point number texture for each color channel ensures that there is almost no loss of color details during the operation. In addition, a 16-bit floating-point color channel can display a larger color range. These are the advantages of HDR.

For users, when the game draws a mask with an HDR effect on it, it immediately looks like a real photo, with blurred halo, meticulous highlights, and natural tones.

However, the format of 16-bit floating-point numbers for each color channel is twice the texture of 8-bit integer formats for each channel; this has a negative impact on the rendering efficiency. Therefore, two new HDR formats are introduced in DirectX 10. The first type is r11g11b10, which indicates that the red and green channels use 11-bit floating point numbers, while the blue channels use 10-bit floating point numbers. So, why not use 11 digits? This is to include the integer 32. People who have studied computers know that when the width of a data unit in the memory is 32 bits, the operation efficiency is the highest; in addition, in texture data, the data width of each pixel is generally a multiple of 2, such as, 16, 32, and 64. Because the human eyes are less sensitive to blue than to red and green, they use less than the other two channels.

Another format is the 9-digit ending number per channel, and all channels share the 5-digit index (as we all know, floating point numbers are represented in the form of an additional ending number index in computers ), add up to 32 bits. These new formats enable the texture to occupy the same amount of memory space as the original one, avoiding large space and bandwidth consumption. In addition, DirectX 10 can support 32-bit (4 channels add up to 128 bits) precision Floating Point Number textures for scenarios requiring accurate scientific computing.

These enhancements in DirectX 10 make it possible to create real-time game scenarios with unprecedented details.

Geometric coloring tool and streaming output

Before DirectX 10 was released, the graphics hardware only had the ability to operate on existing data on the GPU. Vertex shader and pixel shader allow programs to operate on existing data in the memory. This development model is very successful because it performs well in complex grid skin and precise computing of existing pixels. However, this development model cannot generate new data on the image processor. When some objects are dynamically created in the game (such as the shape of a new weapon), the CPU needs to be called. Unfortunately, most games have put a lot of pressure on the CPU, and the chance to dynamically create a large amount of new data during the game has become minimal.

The geometry shader introduced in Shader Model 4.0 allows the program to create new data in the image processor for the first time. This revolutionary event changes the role of the GPU in the system from a processor that can only process existing data to a processor that can process and generate data at extremely fast speeds. Complex algorithms that were previously impossible to implement on graphics systems are now becoming a reality.

The geometric coloring tool is placed in the middle of the vertex coloring tool and the Rasterizer phase. The so-called raster is to scan every triangle in a row and line, and draw them one pixel and one pixel to the screen. The geometric colorant regards the vertex processed by the vertex colorant as the input. For each vertex, the geometric colorant can generate 1024 vertices as the output. This ability to generate large amounts of data is called data amplification ). Likewise, the geometric coloring tool can delete vertices by outputting fewer vertices. Therefore, it is called data minimization ). These two new features make GPU exceptionally powerful in changing data streams.

　　Subdivided virtual displacement maps (displacement mapping with tessellation)

The geometric coloring tool allows virtual displacement maps to be generated on the GPU. Virtual displacement maps are a very popular technology in offline rendering systems. They can be used to render very complex models with a simple model and a height map. A height chart is a gray scale that represents the height of each point on the model. During rendering, the low polygon model is subdivided into more polygon models, and then the polygon is squeezed out based on the information on the height chart to show more detailed models.

In DirectX 9, the GPU cannot generate new data, and the low polygon model cannot be subdivided. Therefore, only a small part of the virtual displacement textures can be implemented. Now, with the power of DirectX 10, thousands of vertices can be created out of thin air, achieving real-time rendering of virtual displacement textures that are subdivided.

　　New Edge-based algorithms

The geometric coloring tool can process three elements: vertex, line, and triangle. Similarly, it can output either of the three elements, although each shader can only output one. When processing the line and triangle, the geometric color generator can obtain edge information. Using vertices on the edges of a line or triangle, You can implement many powerful algorithms. For example, edge information can be used to calculate the model outlines of cartoon rendering and real hair rendering.

　　Stream output)

Before DirectX 10, the ry must be raked and sent to the pixel shader before being written into the memory ). DirectX 10 introduces a new feature called stream output, it allows data to be directly transferred into the frame buffer memory (Frame Buffer Memory) from the vertex or geometric color ). This output can be returned to the rendering pipeline for reprocessing. When the geometric shader is used in combination with the data stream output, GPU can not only process new graphics algorithms, but also improve the efficiency of general and Physical Operations.

With the support of technologies such as data generation and deletion and data stream output, a complete particle system can run independently on the GPU. Particles are generated in the geometric coloring tool and are extended and derived during data expansion. The new particles are output to the memory by the data stream and then transmitted back to the vertex shader for animation. After a while, they gradually disappear and are finally destroyed in the geometric colorant.

Advanced rendering language (HLSL 10)

DirectX 10 has brought many powerful new features to the high level shading language in DirectX 9. This includes the "constant buffers" that can increase the constant update speed, and the "View" that improves the flexibility of operation data in the rendering process ), the switch statement is added to the "integer and bitwise instructions ctions" command prepared for a wider range of algorithms.

　　Constant Buffers)

The coloring program, like a common program, needs to use constants to define various parameters, such as the position and color of the light source, camera position and projection matrix, and some material parameters (such as reflective ). During the rendering process, these constants often need to be updated frequently, and the use and update of hundreds of constants will undoubtedly bring great load to the CPU. The new constant buffer added in DirectX 10 can allocate these constants to the specified buffer based on their usage frequency and update them accordingly.

In a coloring program, DirectX 10 supports up to 16 constant buffers. Each buffer can store 4096 constants. Compared with DirectX 9, DirectX 9 is really poor because it supports up to 256 constants in each coloring program at the same time.

Compared with DirectX 9, DirectX 10 not only provides more constants, but also greatly improves the constant update speed. For constants allocated to the same buffer, we only need to perform one operation to update all of them, instead of updating a single one.

Since the interval between updates of different constants varies, organizing them with the frequency of data usage can achieve higher efficiency. For example, the camera's view matrix changes only between each frame, while material parameters such as Texture Information Change During the switching of elements. So these constant buffers are divided into two parts: the constant buffers for each frame update store the constants that need to be updated between the two frames and update them all at one time between the two frames, in addition, the constant buffer for switching elements to update is also the same. In this way, unnecessary work in the update constant process will be eliminated, so that the entire coloring script runs more smoothly than in DirectX 9.

Views)

In DirectX 9, the Data Types in the shader are strictly divided. For example, the data in the vertex buffer used by the vertex coloring tool cannot be used as the texture data for the pixel coloring tool. In this way, the specific resource types are closely combined with the specific steps in the corresponding rendering process, and the range of resource resources that can be used throughout the rendering process is limited.

DirectX 10 abandons the concept of "strictly differentiated data types. When a piece of data is created, DirectX 10 simply treats it as a bit field in the memory. If you want to use this piece of data without a defined type, you must use a "View ". With "View", there are various methods to read the same piece of data. DirectX 10 supports the use of two "views" for the same resource segment at the same time ".

With this multi-view method, you can use the same data segment for different purposes in different parts of the rendering process. For example, we can use the pixel coloring tool to render a piece of geometric data to a texture, afterwards, the vertex coloring er treats the texture as a vertex buffer through a "View" and renders the data as geometric data. By repeatedly using the same piece of data in different steps throughout the rendering process, "View" provides greater flexibility for "data processing", helping developers achieve more creative and exciting effects.

　　Integer and bitwise instructions)

The "integer and bit commands" are added to the new advanced coloring language ", the advantage of adding the "integer and bit operation commands" operation to its basic operation functions is to help some algorithms implement on the GPU. At last, developers can use integers instead of a strong rotation from the floating point to calculate the exact answer. The index number of the array can now be easily calculated. The era of GPU-free integer operations has finally ended. This will bring great convenience to the development of the shader program.

　　Switch statement)

In DirectX 10, HLSL supports switch statements, which greatly simplifies the encoding of coloring machine scripts with a large number of judgments (branches. One usage is to create an "aircraft carrier-level shader Program" that contains a large number of small coloring programs and a large size of its own. In this "Aircraft Carrier-level coloring Program", we can easily switch between different effects when rendering the same graph element by setting a Material ID in the switch statement. That is to say, every soldier in an army can have different special effects.

Other improvements to DirectX 10

　　Alpha to coverage

In games, polygon models with translucent information textures are often used to simulate complex objects, such as grass, leaves, and barbed wire. If you use a real model, a grass with uneven edges may consume hundreds of polygon. However, with transparent textures, you can use only 2 ~ Three polygon are solved.

Transparent texture Diagram

However, when this translucent texture is used, its border line between opacity and transparency is often ugly. Semi-transparent hybrid technology can solve this problem, but it needs to draw all such objects in the scene from far to near order, in order to ensure that their occlusion relationship is correct, this puts a lot of pressure on the CPU and is not desirable. In earlier versions of DirectX, Alpha testing and mixing are simply a nightmare for graphic programmers.

In DirectX 10, a new technology called Alpha to coverage is used. Using this technology, texture pixels at the junction of transparency and opacity are sampled in Multi-sample mode to achieve anti-aliasing. This solves this problem simply and effectively without introducing high performance overhead. Games in outdoor scenarios will greatly benefit from this technology, and the edge of leaves, barbed wire, and grass will be softer and smoother.

Alpha to coverage Effect

　　Shadow Map Filtering

Shadow Map has gradually become a popular technology for rendering realistic shadows. It can be seen in the next generation of games including war machine, split cell: Dual agents, Ghost Recon, and Assassin's Creed. However, due to the size limitation of the shadow map, the shadow edges implemented by the shadow map often have obvious serrations. In DirectX 10, the shadow map filtering function is officially supported. After filtering, the edge of the Shadow will become softer.