DirectX 11.3 渲染技术解析：Forward、Deferred与Forward+

需积分: 9 130 浏览量更新于2024-07-16 收藏 90.92MB PDF 举报

"这篇文档是关于使用DirectX & Direct3D 11.3进行渲染的详细技术规范，涵盖了3D游戏引擎编程中的几种渲染算法的比较，包括前向渲染、延迟着色以及前向+（分块前向渲染）。在3D游戏开发中，渲染是至关重要的环节，它决定了场景的视觉效果。DirectX是微软推出的一个用于创建高性能图形应用的API，其中Direct3D是专门处理3D图形的部分。Direct3D 11.3版本提供了更高效、更灵活的渲染功能。 1. **前向渲染（Forward Rendering）** 前向渲染是最基础的渲染方式，每个像素由顶点着色器和像素着色器处理。在顶点着色器中，计算几何变换，像素着色器负责计算光照、纹理映射等效果。对于每个像素，都需要重新计算所有光源的影响，因此在有大量光源的场景中效率较低。 2. **延迟着色（Deferred Shading）** 延迟着色是一种优化策略，它首先将场景的几何信息存储到多个缓冲区（G-Buffer），然后在后期处理阶段一次性计算所有光源对像素的影响。这种方式在处理大量光源时非常有效，但需要更多的内存和计算资源。 3. **前向+（分块前向渲染，Forward+或Tiled Forward Rendering）** 前向+是前向渲染和延迟着色的折衷方案，它结合了两者的优点。首先，它按区块组织像素，对每个区块只计算最显著的几个光源，减少了计算量，同时保持了高光等复杂效果。这在处理中等数量光源的场景中表现优秀。在Direct3D 11.3的上下文中，开发者可以利用这些渲染方法的特性，根据具体项目需求选择合适的技术。例如，前向渲染简单易用，适合轻量级应用；延迟着色在大规模光照场景中更有优势；而前向+则提供了一个平衡点，兼顾性能和效果。文档中还详细讨论了各种着色器阶段，如材质、纹理、光照、衰减、点光源、聚光灯和方向光等，并给出了使用HLSL（High-Level Shader Language）实现这些效果的方法。HLSL是Direct3D中用于编写着色器程序的高级语言，允许开发者编写复杂的图形算法。这篇文档深入探讨了Direct3D 11.3中的渲染技术，对于想要提升3D游戏或图形应用性能的开发者来说，是一份宝贵的参考资料。"

2020/4/4 Forward vs Deferred vs Forward+ Rendering with DirectX 11 | 3D Game Engine Programming

https://www.3dgep.com/forward-plus/ 16/102

The Type variable is used to indicate which type of light this is. It can have one of the following

values:

Once again the Light struct is explicitly padded with 8 bytes to match the struct layout in C++

and to make the struct explicitly aligned to 16 bytes which is required in HLSL.

The lights array is accessed through a StructuredBuffer. Most lighting shader implementations

will use a constant buffer to store the lights array but constant buffers are limited to 64 KB in size

which means that it would be limited to about 570 lights before running out of constant memory

on the GPU. Structured buffers are stored in texture memory which is limited to the amount of

texture memory available on the GPU (usually in the GB range on desktop GPUs). Texture

memory is also very fast on most GPUs so storing the lights in a structured buffer did not impose

a performance impact. In fact, on my particular GPU (NVIDIA GeForce GTX 680) I noticed a

considerable performance improvement when I moved the lights array to a structure buffer.

Pixel Shader Continued

The pixel shader for the forward rendering technique is slightly more complicated than the vertex

shader. If you have read my previous article titled Texturing and Lighting in DirectX 11 then you

should already be familiar with most of the implementation of this shader, but I will explain it in

detail here as it is the basis of all of the rendering algorithms shown in this article.

MATER IALS

First, we need to gather the material properties of the material. If the material has textures

associated with its various components, the textures will be sampled before the lighting is

computed. After the material properties have been initialized, all of the lights in the scene will be

iterated and the lighting contributions will be accumulated and modulated with the material

properties to produce the final pixel color.

The [earlydepthstencil] attribute before the function indicates that the GPU should take

advantage of early depth and stencil culling [10]. This causes the depth/stencil tests to be

performed before the pixel shader is executed. This attribute can not be used on shaders that

modify the pixel’s depth value by outputting a value using the SV_Depth semantic. Since this

pixel shader only outputs a color value using the SV_TARGET semantic, it can take advantage of

early depth/stencil testing to provide a performance improvement when a pixel is rejected. Most

GPU’s will perform early depth/stencil tests anyways even without this attribute and adding this

CommonInclude.hlsl

#define POINT_LIGHT 0

#define SPOT_LIGHT 1

#define DIRECTIONAL_LIGHT 2

CommonInclude.hlsl

176 StructuredBuffer<Light> Lights : register( t8 );

ForwardRendering.hlsl

[earlydepthstencil]

float4 PS_main( VertexShaderOutput IN ) : SV_TARGET

{

// Everything is in view space.

float4 eyePos = { 0, 0, 0, 1 };

Material mat = Mat;

2020/4/4 Forward vs Deferred vs Forward+ Rendering with DirectX 11 | 3D Game Engine Programming

https://www.3dgep.com/forward-plus/ 17/102

attribute to the pixel shader did not have a noticeable impact on performance but I decided to

keep the attribute anyways.

Since all of the lighting computations will be performed in view space, the eye position (the

position of the camera) is always (0, 0, 0). This is a nice side effect of working in view space; The

camera’s eye position does not need to be passed as an additional parameter to the shader.

On line 24 a temporary copy of the material is created because its properties will be modified in

the shader if there is an associated texture for the material property. Since the material properties

are stored in a constant buffer, it would not be possible to directly update the materials properties

from the constant buffer uniform variable so a local temporary must be used.

Diffuse

The first material property we will read is the diffuse color.

The default diffuse color is the diffuse color assigned to the material’s DiffuseColor variable. If the

material also has a diffuse texture associated with it then the color from the diffuse texture will be

blended with the material’s diffuse color. If the material’s diffuse color is black (0, 0, 0, 0), then

the material’s diffuse color will simply be replaced by the color in the diffuse texture. The any hlsl

intrinsic function can be used to find out if any of the color components is not zero.

Opacity

The pixel’s alpha value is determined next.

By default, the fragment’s transparency value is determined by the alpha component of the diffuse

color. If the material has an opacity texture associated with it, the red component of the opacity

texture is used as the alpha value, overriding the alpha value in the diffuse texture. In most cases,

opacity textures store only a single channel in the first component of the color that is returned

from the Sample method. In order to read from a single-channel texture, we must read from the

red channel, not the alpha channel. The alpha channel of a single channel texture will always be

ForwardRendering.hlsl

float4 diffuse = mat.DiffuseColor;

if ( mat.HasDiffuseTexture )

{

float4 diffuseTex = DiffuseTexture.Sample( LinearRepeatSampler, IN.tex

if ( any( diffuse.rgb ) )

{

diffuse *= diffuseTex;

}

else

{

diffuse = diffuseTex;

}

ForwardRendering.hlsl

float alpha = diffuse.a;

if ( mat.HasOpacityTexture )

{

// If the material has an opacity texture, use that to override the di

alpha = OpacityTexture.Sample( LinearRepeatSampler, IN.texCoord ).r;

}

剩余2573页未读，继续阅读

qhx19870506

粉丝: 1
资源: 35

DirectX 11.3 渲染技术解析：Forward、Deferred与Forward+

Practical Rendering and Computation with Direct3D 11

《Practical Rendering and Computation with Direct3D11》

GPU Pro & GPU ZEN.7z.001

GPU Pro & GPU ZEN.7z.003

GPU Pro & GPU ZEN.7z.002

GPU Pro & GPU ZEN.7z.005

GPU Pro & GPU ZEN.7z.004

Advanced Real Time Rendering in 3D Graphics and Games.pdf

Practical.Rendering.and.Computation.with.Direct3D.11

Practical Rendering and Computation with Direct3D 11源码

最新资源