GPU Zen 2：探索高级实时渲染技术精华

需积分: 5 117 浏览量更新于2024-06-27 收藏 22.04MB PDF 举报

"GPU Zen 2 Advanced Rendering" 是一本由 Wolfgang Engel 编辑的专业书籍，由 Black Cat Publishing Inc. 出版，专注于探讨快速发展的实时游戏渲染领域中的最新技术。这本书汇集了针对GPU编程的尖端贡献，特别关注GPU Zen 2在高级渲染技术上的进步。它不仅介绍了GPU Zen 2架构的特性，还涵盖了如适应性GPU曲面细分、计算着色器的应用以及向量化可见性在所有频率直接照明中的实践。在本书的第一部分，作者 Jad Khoury、Jonathan Dupuy 和 Christophe Riccio 详细阐述了"Adaptive GPUTessellation with Compute Shaders"（自适应GPU曲面细分与计算着色器）。这部分内容从介绍开始，讲解了如何利用GPU的并行计算能力对传统图形流水线进行扩展，通过计算着色器实现动态的三角形细分，从而提高模型的复杂度和细节呈现。他们讨论了这一技术的优势，如性能提升和更高效的内存使用，并对相关工作进行了总结，同时感谢了合作团队的支持。第二章探讨了"Applying Vectorized Visibility on All Frequency Direct Illumination"（向量化可见性在全频率直接光照中的应用）。作者 Ho Chun Leung、Tze Yui Ho、Zhenni Wang 和 Chi Sing Leung 提出了如何利用向量数据结构来优化光线追踪过程中的可见性测试，这在现代GPU中是一个关键的性能瓶颈。他们展示了如何通过向量化操作加速高频率直接照明计算，以实现更真实的全局照明效果，同时保持实时渲染的要求。整体来看，GPU Zen 2 Advanced Rendering提供了一个深入理解GPU渲染技术和GPU Zen 2架构在游戏开发中实际应用的平台。读者可以从中学习到如何利用GPU的最新技术提升图形质量，优化性能，并为游戏开发者提供了宝贵的实践指导和研究素材。这本书适合专业图形程序员、游戏引擎开发者以及对实时渲染技术感兴趣的读者。

4 1. Adaptive GPU Tessellation with Compute Shaders

array. First, we show how we manage our implicit subdivision scheme in Section 1.2.

Then, we provide implementation details for rendering programs we wrote that lever-

age our subdivision scheme in Section 1.3.

1.2 Implicit Triangle Subdivision

1.2.1 Subdivision Rule

Polygon reﬁnement algorithms build upon a subdivision rule. The subdivision rule de-

scribes how an input polygon splits into subpolygons. Here, we rely on a binary triangle

subdivision rule, which is illustrated in Figure 1.1(a). The rule splits a triangle into

two similar subtriangles 0 and 1, whose barycentric-space transformation matrices are

respectively

1 2 1 2 1 2

0 0 1

 

 

 

 

 

 

, (1.1)

and

1 2 1 2 1 2

0 0 1

 



 

  

 

 

. (1.2)

Listing 1.1 shows the GLSL code we use to procedurally compute either

based on a binary value. It is clear that at subdivision level



, the rule produces

triangles; Figure 1.1(b) shows the reﬁnement produced at subdivision level



which consists of

2 16



triangles.

Figure 1.1. The (a) subdivision rule we apply on a triangle (b) uniformly and (c) adaptively.

The subdivision levels for the red, blue, and green nodes are respectively 2, 3, and 4.

1.2 Implicit Triangle Subdivision 5

mat3 bitToXform(in uint bit)

{

float s = float(bit) - 0.5;

vec3 c1 = vec3( s, -0.5, 0);

vec3 c2 = vec3(-0.5, -s, 0);

vec3 c3 = vec3(+0.5, +0.5, 1);

return mat3(c1, c2, c3);

}

Listing 1.1. Computing the subdivision matrix

from a binary value.

1.2.2 Implicit Representation

By construction, our subdivision rule produces unique subtriangles at each step. There-

fore, any subtriangle can be represented implicitly via concatenations of binary words,

which we call a key. In this key representation, each binary word corresponds to the

partition (either 0 or 1) chosen at a speciﬁc subdivision level; Figure 1.1(b, c) shows

the keys associated to each triangle node in the context of (b) uniform and (c) adaptive

subdivision. We retrieve the subdivision matrix associated to each key through succes-

sive matrix multiplications in a sequence determined by the binary concatenations. For

example, letting

0100

denote the transformation matrix associated to the key 0100, we

have

M M M M M

0100 0 1 0 0

   

(1.3)

In our implementation, we store each key produced by our subdivision rule as a 32-bit

unsigned integer. Below is the bit representation of a 32-bit word, encoding the key

0100. Bits irrelevant to the code are denoted by the ‘_’ character.

MSB LSB

____ ____ ____ ____ ____ ____ ___1 0100

Note that we always prepend the key’s binary sequence with a binary value of 1 so we

can track the subdivision level associated to the key easily. Listing 1.2 provides the

GLSL code we use to extract the transformation matrix associated to an arbitrary key.

Since we use 32-bit integers, we can store up to a

32 1 31

 

levels of subdivision,

which includes the root node. Naturally, more levels require longer words. Because

longer integers are currently unavailable on many GPUs, we emulate them using integer

vectors, where each component represents a 32-bit wide portion of the entire key. For

more details, see our implementation, where we provide a 63-level subdivision algo-

rithm using the GLSL uvec2 datatype.

6 1. Adaptive GPU Tessellation with Compute Shaders

mat3 keyToXform(in uint key)

{

mat3 xf = mat3(1);

while (key > 1u)

{

xf = bitToXform(key & 1u) * xf;

key = key >> 1u;

}

return xf;

}

Listing 1.2. Key to transformation matrix decoding routine.

1.2.3 Iterative Construction

Subdivision is recursive by nature. Since GPU execution units lack stacks, implement-

ing GPU recursion is diﬃcult. In order to circumvent this diﬃculty, we store the trian-

gles produced by our subdivision as keys inside a buﬀer that we update iteratively in a

ping-pong fashion; we refer to this double-buﬀer as the subdivision buﬀer. Because

our keys consists of integers, our subdivision buﬀer is very compact. At each iteration,

we process the keys independently in a compute shader, which is set to write in the

second buﬀer. We allow three possible outcomes for each key: it can be subdivided to

the next level, downgraded to the previous subdivision level, or conserved as is. Such

operations are very straightforward to implement thanks to our key representation. The

following bit representations match the parent of the key given in our previous example

along with its two children:

MSB LSB

parent: ____ ____ ____ ____ ____ ____ ____ 1010

key: ____ ____ ____ ____ ____ ____ ___1 0100

child1: ____ ____ ____ ____ ____ ____ __10 1000

child2: ____ ____ ____ ____ ____ ____ __10 1001

Note that compared to the key representation, the other keys are either 1-bit expansions

or contractions. The GLSL code to compute these representations is shown in List-

ing 1.3; it simply consists of bit shifts and logical operations, and is thus very cheap.

Listing 1.4 provides the pseudocode we typically use for updating the subdivision

buﬀer in a GLSL compute shader. In practice, if a key needs to be split, it emits two

new words, and the original key is deleted. Conversely, when two sibling keys must

merge, they are replaced by their parent's key. In order to avoid generating two copies

of the same key in memory, we only emit the key once from the 0-child, identiﬁed

剩余303页未读，继续阅读

mountainlord

粉丝: 5
资源: 18

GPU Zen 2：探索高级实时渲染技术精华

GPU Zen Advanced Rendering Technique

GPUZen_AdvancedRenderingTechnique

推荐学习shader的相关图书

ubuntu18.04怎么让gazebo使用gpu

ubuntu18.04怎么让gazebo使用gpu打开indoor1文件

offscreen rendering

Failed to execute 'texSubImage2D' on 'WebGL2RenderingContext': Overload resolution failed.

Unity multithreaded Rendering的介绍

three.cjs:18071 Uncaught TypeError: Failed to execute 'uniform2fv' on 'WebGL2RenderingContext': Overload resolution failed. a

最新资源