2021.09.19

• ue motion blur
• shader 性能考虑
• GPU的工作原理

ue motion blur

使用多instance绘制，只使用vertex index的方式来

记得同事来问的时候，motion blur有一部是要根据一个范围内的最大最小velocity差来判断使用哪一种motion blur的策略，但是因为这个范围一开始是固定死的，所以在动静态物的边缘会留下一些残影的线条。这里就需要根据velocity来动态的确定这个范围，即在边缘这个范围要扩大。
ue的实现还蛮妙的，通过instance draw来实现一个，即每个tile只传递顶点的index，具体矩形的大小由velocity确定，这个大小会作为depth写入深度图，通过深度覆盖来保留更大的范围的值。

void VelocityScatterVS(
	uint VId : SV_VertexID,
	uint IId : SV_InstanceID,
	out nointerpolation float4 OutColor : TEXCOORD0,
	out float4 OutPosition : SV_POSITION)
{
	OutPosition = float4(0, 0, 0, 1);

	// needs to be the same on C++ side (faster on NVIDIA and AMD)
	uint QuadsPerInstance = 8;

	// remap the indices to get vertexid to VId and quadid into IId
	IId = IId * QuadsPerInstance + (VId / 4);
	VId = VId % 4;

	// triangle A: 0:left top, 1:right top, 2: left bottom
	// triangle B: 3:right bottom, 4:left bottom, 5: right top
	float2 CornerOffset = float2(VId % 2, VId / 2) * 2 - 1;

	uint2 PixelPos = uint2(IId % VelocityTile_ViewportMax.x, IId / VelocityTile_ViewportMax.x);

	BRANCH
	if (PixelPos.y >= VelocityTile_ViewportMax.y)
	{
		OutColor = 0;
		return;
	}

	float2 SvPosition = PixelPos + 0.5;

	float4 MinMaxVelocity = VelocityTileTexture[PixelPos];
	OutColor = MinMaxVelocity;

	float4 MinMaxVelocityPixels = MinMaxVelocity * MotionBlur_VelocityScaleForTiles;
	float2 VelocityPixels = MinMaxVelocityPixels.zw;

	// Is the velocity small enough not to cover adjacent tiles?
	BRANCH
	if (dot(VelocityPixels, VelocityPixels) * 16 * 16 <= 0.25)
	{
		OutPosition.xy = (SvPosition + CornerOffset * 0.5 - VelocityTile_ScreenPosToViewportBias) / VelocityTile_ScreenPosToViewportScale.xy;
		OutPosition.z = 0.0002; // zero clips
		return;
	}

	float  VelocityLengthPixelsSqr = dot(VelocityPixels, VelocityPixels);
	float  VelocityLengthPixelsInv = rsqrtFast(VelocityLengthPixelsSqr);
	float  VelocityLengthPixels = VelocityLengthPixelsSqr * VelocityLengthPixelsInv;
	float2 VelocityDir = VelocityPixels * VelocityLengthPixelsInv;

	// Project pixel corner on to dir. This is the oriented extent of a pixel.
	// 1/2 pixel because shape is swept tile
	// +1/2 pixel for conservative rasterization
	// 99% to give epsilon before neighbor is filled. Otherwise all neighbors lie on edges of quad when no velocity in their direction.
	// dot(abs(VelocityDir), float2(1, 1))
	float Extent = abs(VelocityDir.x) + abs(VelocityDir.y);
	CornerOffset *= float2(VelocityLengthPixels, 0) + Extent.xx * 0.99;

	// Orient along velocity direction
	float2 AxisX = VelocityDir;
	float2 AxisY = float2(-VelocityDir.y, VelocityDir.x);
	CornerOffset = AxisX * CornerOffset.x + AxisY * CornerOffset.y;

	OutPosition.xy = (SvPosition + CornerOffset - VelocityTile_ScreenPosToViewportBias) / VelocityTile_ScreenPosToViewportScale;

	// Depth ordered by velocity length
	OutPosition.z = (ScatterPass == VELOCITY_SCATTER_PASS_MAX) ? VelocityLengthPixels : length(MinMaxVelocityPixels.xy);
	OutPosition.z = clamp(OutPosition.z / VelocityTile_ScreenPosToViewportScale.x * 0.5, 0.0002, 0.999);
}

void VelocityScatterPS(
	nointerpolation float4 InColor : TEXCOORD0,
	out float4 OutColor : SV_Target0)
{
	OutColor = InColor;
}

shader 性能考虑

• if for
• hi-z 一个 pass 做完
  hi-z要生成多个mipmap level的depth贴图，现在是一个level一个draw call完成的, 其实是用同步可以完成一个draw call绘制所有

GPU的工作原理

https://www.zhihu.com/zvideo/1421421171497304064