GPU Pro 3：高级渲染技术详解

3星 · 超过75%的资源需积分: 9 164 浏览量更新于2024-07-24 1 收藏 31.13MB PDF 举报

"GPU PRO 3 - Advanced Rendering Techniques" 《GPU PRO 3 - Advanced Rendering Techniques》是一本关于游戏图形和引擎开发的专业书籍，由ShaderX系列的作者Wolfgang Engel编辑。该书涵盖了GPU图形学的高级渲染技术，是游戏开发者和图形引擎设计师的重要参考资料。在GPU图形学领域，GPU（图形处理器）扮演着至关重要的角色，它能够快速处理复杂的图形计算任务，为游戏和实时渲染提供强大的性能支持。本书深入探讨了如何利用GPU的潜力来实现更逼真、更高性能的渲染效果。内容可能包括但不限于以下知识点： 1. **光线追踪**：一种高级的渲染技术，模拟光线在现实世界中的传播，生成高度真实的阴影、反射和折射效果。 2. **着色器编程**：包括顶点着色器、像素着色器、几何着色器等，用于控制物体表面的视觉表现，如颜色、纹理和光照。 3. **延迟渲染**：一种优化渲染效率的方法，通过将渲染分为多个阶段，如深度缓冲、光照计算和混合，以处理大量复杂场景。 4. **物理基础的光照模型**：如基于物理的渲染（PBR），通过模拟真实世界的光学现象，如镜面反射、漫反射和次表面散射，实现更加真实的材质表现。 5. **纹理和贴图技术**：包括法线贴图、置换贴图、环境光遮蔽贴图等，用于增强物体表面的细节和质感。 6. **实时全局光照**：实现在动态环境中光线的实时交互，提升环境的真实感。 7. **抗锯齿技术**：减少图像边缘的锯齿现象，提高图像质量。 8. **多采样抗锯齿（MSAA）与超级采样抗锯齿（SSAA）**：两种常见的抗锯齿技术，用于平滑图像细节。 9. **硬件加速技术**：利用GPU的并行计算能力，加速计算密集型任务，如粒子系统、流体动力学模拟等。 10. **实例化和批量处理**：有效优化大量相似对象的渲染，降低GPU负载。 11. **阴影技术**：如阴影映射、PCF（ Percentage-Closer Filtering）和VSM（Visibility Shadow Maps）等，提高场景的深度感知。 12. **图形优化**：探讨如何减少带宽使用、内存管理优化以及GPU计算效率的提升。通过阅读《GPU PRO 3》，读者可以了解到当前图形渲染领域的前沿技术和最佳实践，这对于提升游戏开发的视觉效果和性能至关重要。书中包含的信息来源于权威和备受尊重的来源，虽然尽力确保内容的准确性，但作者和出版社不承担因使用这些材料而导致的任何后果。此外，对于可能未获得授权的版权材料，作者和出版社承诺会在后续的重印版中进行修正。

1. Vertex Shader Tessellation 5

Figure 1.1. Assigning IDs to every subtriangle of a tessellation with tessellation fac-

tor N.

3. Compute the index of the current mesh triangle from SV_VertexID.

4. Fetch the three indices for the current mesh triangle from the index buﬀer

using Load().

5. Fetch the vertex data for all three vertices of the current mesh triangle from

the vertex buﬀers using the indices from Step 4.

6. Modify the barycentric coordinates from Step 2 to move to the right vertex

of the subtriangle based on SV_VertexID.

7. Use the barycentric coordinates from Step 7 to compute the output vertex

from three sets of vertex attributes from mesh vertices fetched in Step 5.

Listing 1.1 shows a real-world implementation of Steps 1–7.

// original vertex input structure

struct VS_RenderSceneInput

{

float3 f3Position : POSITION;

float3 f3Nor mal : NORMAL;

float2 f2TexCoord : TEXCOORD;

};

// ib and vb bound as shader resource by t he vertex shader

Buffer<uint> g_bufIndices : register( t0 );

Buffer<float4 > g_bufVertices : register( t1 );

Vs_to_ps VS_Tessellate( uint in_verte xID : SV_VertexID )

{

Vs_to_ps O;

// g_uSubTriangles holds the number of subtriangles f or the

// current tessellation factor e.g ., (N *N)-1

6 I Geometry Manipulation

// compute what subtriangle we ’re in at the moment

uint subTriID = ( in_vertexID / 3 ) % g_uSubTriangles ;

// subTriID to float

fl o at fSubTriID = f l oa t (subTriID );

// compute barycentric coords u , v, and w

fl o at fRow = floor ( sqrt ( fSubTriID ) ); // how far we are along u

fl o at incuv = 1.0f / g_fTe ssFactor ;

fl o at u = ( 1.0f + fRow ) / g_fTess Factor ;

// compute how far along the row we are

fl o at fCol = fSubTriID - ( fRow * fRow );

uint uCol = uint ( fCol );

fl o at v = incuv * floor( fCol * 0.5 f );

// correct u

u -= v ;

// setup w

fl o at w = 1.0 f - u - v ;

// compute the vertex index in the current mesh

uint vertexID = ( ( in_vertex ID / 3 ) / g_uSu bTria ngles ) * 3

+ ( in_ vertexID % 3 );

// compute offsets for fetching indices from index buffer

uint uOffset1 = ( vertexID / uint (3) ) * 3;

uint3 uOffset3 = uint3 ( uOffset1 , uOffset1 + 1, uOffset1 + 2 )

+ g_StartIn dexLocation .xxx; // start offset for idxs

// fetch indices

uint3 indices;

indices .x = g_bufIndices . Load( uOffset3. x ). x;

indices .y = g_bufIndices . Load( uOffset3. y ). x;

indices .z = g_bufIndices . Load( uOffset3. z ). x;

// add base vertex location from constant buffer

indices += g_BaseVerte xLocation . xxx ;

// compute offset for vertices into the vertex buffer

uint3 voffset3 = indices * g_VertexStride.xxx + g_VertexStart . xxx ;

// load vertex data for u =1.0 - vertex 0 of the mesh triangle

fl o at4 dataU0 = g_bufVertices .Load ( voffset3 .x );

fl o at4 dataU1 = g_bufVertices .Load ( voffset3 .x + 1 );

fl o at3 f3PosU = dataU0 . xyz ;

fl o at3 f3NormU = f l oa t3 ( dataU0 .w , dataU1 . xy );

fl o at2 f2TexU = dataU1 . zw ;

// load vertex data for v =1.0 - vertex 1 of the mesh triangle

fl o at4 dataV0 = g_bufVertices .Load ( voffset3 .y );

fl o at4 dataV1 = g_bufVertices .Load ( voffset3 .y + 1 );

fl o at3 f3PosV = dataV0 . xyz ;

fl o at3 f3NormV = f l oa t3 ( dataV0 .w , dataV1 . xy );

fl o at2 f2TexV = dataV1 . zw ;

// load vertex data for w =1.0 - vertex 2 of the mesh triangle

fl o at4 dataW0 = g_bufVertices .Load ( voffset3 .z );

fl o at4 dataW1 = g_bufVertices .Load ( voffset3 .z + 1 );

fl o at3 f3PosW = dataW0 . xyz ;

fl o at3 f3NormW = f l oa t3 ( dataW0 .w , dataW1 . xy );

fl o at2 f2TexW = dataW1 . zw ;

8 I Geometry Manipulation

Figure 1.2. Fractional transitioning between a tessellation factor 3.0 and a tessellation

factor 5.0 of an edge.

Figure 1.2 shows the tessellation that a fractional tessellation factor of roughly

3.5 would create.

For edges of the tessellated triangles and for interior vertices that need a lower

than maximum fractional tessellation factor, the vertex shader must ensure that

a number of zero-area triangles get created.

This is not the most eﬃcient way of creating a tessellation, especially when

there are big diﬀerences between the tessellation factors on the three edges of a

triangle or the four edges of a quad. Nevertheless, it is the only way to deal with

this problem on DX10-class hardware.

In general, however, this does not pose a severe problem, since one can, for

example, use one fractional tessellation factor for an object or a mesh. This will

work nicely as long as the objects or meshes that get tessellated are not too large.

If objects or meshes get large, for example, when the mesh represents a large

terrain, then one tessellation factor is not enough. In such a case, it makes sense

to break up the mesh into a number of patches that have similar maximum-per-

edge fractional tessellation factors. Each set of patches can then be sent to the

vertex shader for tessellation in one draw call.

Listing 1.2 shows an implementation of a vertex shader that supports per-

edge fractional tessellation factors for quadrangular terrain patches. For the quad

domain, one needs to issue six vertices per subquad (generated by the tessellation)

since the vertex shader needs to output two triangles per quad.

Please note that the vertex shader in Listing 1.2 relies on the use of instanced

draw calls to kick oﬀ the tessellating vertex shader. The instanced draw calls

issue six vertices per subquad and one instance per quad of the untessellated

terrain.

static const float2 uv_shift[4] = {

float2( 0.0f, 0.0f ),

float2( 1.0f, 0.0f ),

float2( 1.0f, 1.0f ),

float2( 0.0f, 1.0f ),

};

VS_OUTPUT VSTessellateEdges( uint in_vertId : SV_VertexID,

uint in_instID : SV_InstanceID )

1. Vertex Shader Tessellation 9

{

VS_OUTPUT O;

int i;

// get the four tess factors for the four edges of the quad

fl o at4 f4E dgeFactor = g_f4EdgeFacto r ;

// get the maximum tess factor ( needs to be 2 + max edge factor)

fl o at tf = f l oa t ( g_uVSTessFactor .x );

// use vertex id to compute the id of the subquad

// and to compute the row /col in the quad tessellati on

uint uSub QuadID = in_vertId / 6;

fl o at f SubQ uadID = f l oa t ( uSubQua dID );

fl o at inv_tf = 1.0 f / tf ;

fl o at fRow = f lo a t ( uSubQ uadID / g_ uVSTe ssFac tor . x );

fl o at fCol = floor ( f SubQuadID - fRow * tf );

// now compute u and v

fl o at v = fRow * inv_tf ;

fl o at u = fCol * inv_tf ;

// compute offset into vertex buffer that holds

// the vertices of the terrain

uint offset = ( in_instID ) * 4;

// fetch data for the 4 corners of the quad

fl o at4 data0 = g_bufVertices.Load ( offset );

fl o at4 data1 = g_bufVertices.Load ( offset + 1 );

fl o at4 data2 = g_bufVertices.Load ( offset + 2 );

fl o at4 data3 = g_bufVertices.Load ( offset + 3 );

fl o at3 f3Pos [4];

// use data to init the corner positions in f3Pos [4]

. . .

// update u , v based on what vertex of the 6 vertices

// that are used to output the 2 triangles that make

// up a subquad (== quad created by the tessellation)

uint vID = in_vertId % 6;

vID = vID < 3 ? ( vID == 2 ? 3 : vID ) :

( vID > 4 ? 3 : ( vID - 2 ) );

fl o at2 uv_off = inv_tf * uv_shift[ vID ];

u += uv_off . x;

v += uv_off . y;

// compute screen space adjusted tessellation factors for each

// edge of the original input quad

// please note that on the CPU the same tes sefactors

// get computed in order to bin terrain quads into bins

// with comparable maximum tes sellation factors

f4EdgeFactor = com put eEd geTessFactors( f3Pos[0] , f3Pos[1] ,

f3Pos[2] , f3Pos [3] );

// combine tessellation factors to a single one that depends

// on the current uv position in the highest res tessellation

fl o at4 f4EdgeFla g = ( fl oa t4 ( 1.0 f - v, 1.0f - u , v , u ) +

( 1.0 f /128.0 f ). xxxx ) >= (1.0 f). xxxx ?

(1.0 f ). xxxx : (0.0f ). xxxx ;

剩余391页未读，继续阅读

airfansq

粉丝: 1
资源: 3

GPU Pro 3：高级渲染技术详解

GPU Pro 3 Advanced Rendering Techniques pdf 7z压缩

GPU Pro 5- Advanced Rendering Techniques

GPU PRO 3: Advanced Rendering Techniques

GPU Pro: Advanced Rendering Techniques (3/3)

GPU Pro: Advanced Rendering Techniques (1/3)

GPU Pro-Advanced Rendering Techniques

GPU Pro 2: Advanced Rendering Techniques

ShaderX5 - Advanced Rendering Techniques

ShaderX7 - Advanced Rendering Techniques

英文原版-GPU Pro 5 Advanced Rendering Techniques 1st Edition

最新资源