Velocity Scene Texture Data Integrity Issues

When a Post-Process Material uses the Scene Texture Material Expression, the following code is generated:

```
MaterialFloat2 Local0 = Parameters.TexCoords[0].xy;
MaterialFloat2 Local1 = ClampSceneTextureUV(ViewportUVToSceneTextureUV(DERIV_BASE_VALUE(Local0), 28), 28);
MaterialFloat4 Local2 = SceneTextureLookup(Local1, 28, false);
```

The UVs (`Local1`) are in Buffer space, due to `ViewportUVToSceneTextureUV(…)`
`SceneTextureLookup(…)` passes the UVs directly through to `PostProcessVelocityLookup(...)`. Depending on if there is velocity encoded, the UVs taken into `PostProcessVelocityLookup(...)` are interpreted as being in Buffer Space or Viewport Space. Annotations below show where:

```
// Passed UV is in Buffer UV space
float2 PostProcessVelocityLookup(float Depth, float2 UV)
{
// UV needs to be in Buffer UV space
float4 EncodedVelocity = Texture2DSampleLevel(SceneTexturesStruct.GBufferVelocityTexture, SceneTexturesStruct_GBufferVelocityTextureSampler, UV, 0);
float2 Velocity;
if( EncodedVelocity.x > 0.0 )

{ Velocity = DecodeVelocityFromTexture(EncodedVelocity).xy; }

else

{ // UV assumed to be in ViewportUV space, but instead is in buffer space float2 ScreenPos = ViewportUVToScreenPos(UV); float4 ThisClip = float4( ScreenPos, Depth, 1 ); float4 PrevClip = mul( ThisClip, View.ClipToPrevClip ); float2 PrevScreen = PrevClip.xy / PrevClip.w; Velocity = ScreenPos - PrevScreen; }

return Velocity;
}
```

This can lead to incorrect velocity vectors for non-moving objects when the Viewport does not cover the entire buffer, which is common in the Editor, and also affects splitscreen.

The visual result is that the “focal point” of the velocity isn’t at the center of the screen, when sampled in a Post-Process Material. IE, if you look down at a flat surface and spin, with a Post-Process Material showing the Velocity vectors, they will not make a circle around the center of the screen, but wherever the center of the buffer happens to be.

1. Download the attached test project and open.
2. Resize the viewport to be larger, release, then resize again to be smaller. The greater the difference from the large size to the size used in the test, the more visible the issue will be. This step will result in the underlying rendering buffer being larger than the viewport.
2. Move the camera over the default ground mesh, face down, and spin the camera along the vertical axis.
3. Observe the lines that appear on screen. The red lines show pixel velocity as sampled by the Material Expression "SceneTextureSample", while the green lines show a corrected calculation.
4. Observe that the green lines make a circle around the center of the viewport, while the red lines make a circle around some point to the lower right.
5. A texture has been added (/Game/Screenshot) that is a screenshot of this, with the centers marked.

Alternate steps (splitscreen)
2. Start the game in Standalone
3. Face the camera down and spin.
4. Observe the vectors drawn are all yellow (two different calculations are identical)
5. Add a splitscreen player with the console command "DebugCreatePlayer 1"
6. Repeat step 3
7. Observe that the red and green vectors disagree. The green vectors circle the viewport, while the red vectors circle the center of the buffer shared between the two viewports.