Grass Interaction - Part 3

In this third part, we will set up the driver code of the Entity Influence system and the Fade kernel, calculating non-grass-specific data required by the motion equation.

The C# side is split the same way as the GPU side: gameplay state (who the entities are, where the coverage window sits) lives in a manager; GPU resources and dispatches live in a URP renderer feature.

[!info] Overhaul 2026 This post is current being revised.

NOTE: All using declarations are hidden for clarity. You should be able to auto-complete them. Put the scripts under a PlantInteraction namespace if you want them to match the sample project.

Entities#

We start by defining the interface of our entities:

1
public interface IEntityInfluenceInfo
2
{
3
    public Vector3 WorldPos { get; }
4
    public float Radius { get; }
5
    public Vector3 WorldVel { get; }
6
    public float Height { get; }
7
}

C# doesn’t have multiple inheritance, thus using interface is the most flexible solution. The interface matches closely what we have defined in the compute shader InfluenceInfo. However, since we need to push the data into a buffer, and an interface is not blittable, we need a struct:

1
public struct EntityInfluenceInfo
2
{
3
    public const int Size = sizeof(float) * 8;
4
    public Vector3 worldPos;
5
    public float radius;
6
    public Vector3 worldVel;
7
    public float height;
8
    public EntityInfluenceInfo(IEntityInfluenceInfo info)
9
    {
10
        worldPos = info.WorldPos;
11
        worldVel = info.WorldVel;
12
        radius = info.Radius;
13
        height = info.Height;
14
    }
15
}

Size is the structured-buffer stride: 8 floats, 32 bytes, matching the HLSL packing from part 2 (float3 + float + float3 + float).

NOTE: The order of the fields in EntityInfluenceInfo must match InfluenceInfo declared in HLSL. When transmitting data from CPU to GPU, there’s no way to remap fields as the data is essentially raw (void*). Furthermore, the computer does not give you any error message when you get the order wrong except when the ordering changed the size of the struct.

This would seem redundant, having both an interface and a struct, why not just having a struct and store it as a member field? The reason is we want our system to take care of data updating, instead of letting the containing class to call update per-frame (if we only retain EntityInfluenceInfo struct, the containing class will also need to set its values per-frame). This would make the API more friendly.

We will add a script called EntityInfluenceProvider that can be attached to any game object:

1
public class EntityInfluenceProvider : MonoBehaviour, IEntityInfluenceInfo
2
{
3
    public float radius = 1;
4
    public float height = 1;
5
    private Vector3? _lastPos;
6
    public Vector3 WorldPos => transform.position;
7
    public float Radius => radius;
8
    public Vector3 WorldVel { get; private set; }
9
    public float Height => height;
10

11
    private void Update()
12
    {
13
        if (_lastPos.HasValue)
14
        {
15
            WorldVel = (WorldPos - _lastPos.Value) / Time.deltaTime;
16
        }
17
        _lastPos = WorldPos;
18
    }
19

20
    private void OnEnable()
21
    {
22
        EntityInfluenceManager.Instance.AddEntity(this);
23
    }
24

25
    private void OnDisable()
26
    {
27
        EntityInfluenceManager.Instance.RemoveEntity(this);
28
    }
29
}

Entity Influence Manager#

Next, we will create a class that gathers all the info. For simplicity, we will make it a singleton.

1
public partial class EntityInfluenceManager
2
{
3
    [AutoStaticsCleanup]
4
    private static EntityInfluenceManager _instance;
5
    public static EntityInfluenceManager Instance
6
    {
7
        get {
8
            _instance ??= new();
9
            return _instance;
10
        }
11
    }
12
}

[AutoStaticsCleanup] is a small helper that nulls the instance on domain reload introduced in the newer Unity 6 (saw it in 6.7a, could be earlier), so the editor does not keep a dead singleton.

We need a way to let other components to register entity influence info, as well as removal. Add these members to the class:

1
private List<IEntityInfluenceInfo> _entities = new();
2

3
public void AddEntity(IEntityInfluenceInfo entity)
4
{
5
    if (_entities.Contains(entity)) return;
6
    _entities.Add(entity);
7
}
8

9
public void RemoveEntity(IEntityInfluenceInfo entity)
10
{
11
    _entities.Remove(entity);
12
}

For delta time, we record a timestamp and update Dt during system update. Fade will add this to every pixel’s elapsed time:

1
private float? _lastTimestamp;
2
public float Dt { get; private set; }

System Center#

In Part 2 we talked about the texture should follow the protagonist. Therefore, we need a way to keep track of the center to produce center displacement and center position:

1
private EntityInfluenceCenter _center;
2
public Vector2 CenterDisplacement { get; private set; } = Vector2.zero;
3
private Vector2? _lastCenterPosition;
4

5
public Vector2 Center
6
{
7
    get {
8
        var pos = _center.Position;
9
        return new Vector2(pos.x, pos.z);
10
    }
11
}
12

13
public bool HasCenter => _center is not null;
14

15
public void SetCenter(EntityInfluenceCenter center)
16
{
17
    _center = center;
18
}

HasCenter is the pass’s “should I even run?” flag. Center is XZ only — the coverage window is a square on the ground plane. CenterDisplacement is this frame’s XZ delta in world units; later, the render pass converts it to pixels before uploading _CenterMotion.

The center is usually an entity as well, so we will subclass the EntityInfluenceProvider:

1
public class EntityInfluenceCenter : EntityInfluenceProvider
2
{
3
    private void Awake()
4
    {
5
        EntityInfluenceManager.Instance.SetCenter(this);
6
    }
7

8
    private void OnDestroy()
9
    {
10
        EntityInfluenceManager.Instance.SetCenter(null);
11
    }
12

13
    public Vector3 Position => transform.position;
14
}

System Update#

Once per frame the pass hands us a staging buffer. We fill it from the registered providers and return how many slots are live. This is also where Dt and CenterDisplacement are computed, so the GPU sees a consistent snapshot:

1
internal int Update(NativeArray<EntityInfluenceInfo> stagingBuffer)
2
{
3
    if (_center is null) return 0;
4
    if (_lastTimestamp.HasValue)
5
    {
6
        Dt = Time.time - _lastTimestamp.Value;
7
    }
8
    _lastTimestamp = Time.time;
9
    var currentCenter = Center;
10
    if (_lastCenterPosition.HasValue)
11
    {
12
        CenterDisplacement = currentCenter - _lastCenterPosition.Value;
13
    }
14
    _lastCenterPosition = currentCenter;
15
    var count = Mathf.Min(stagingBuffer.Length, _entities.Count);
16
    for (var i = 0; i < count; i++)
17
    {
18
        stagingBuffer[i] = new EntityInfluenceInfo(_entities[i]);
19
    }
20
    return count;
21
}

That is all of the non-graphics code. Notice there is no GraphicsBuffer here. The manager holds references (List<IEntityInfluenceInfo>) and produces a blittable snapshot; the pass owns the native copies:

Copy	Where	What it stores
`List<IEntityInfluenceInfo>`	manager, CPU	references to live providers
`NativeArray<EntityInfluenceInfo>`	pass, CPU	packed values for this frame
`GraphicsBuffer`	pass, GPU	the same packed values, bound as `_InfluenceInfo`

Custom Renderer Feature#

Assume you have seen Unity 6 URP’s Render Graph API at least once. If not, the mental model is: during recording you declare resources and a callback; later, during execution, that callback emits the actual CommandBuffer work. We add a compute pass by callingAddComputePass. Persistent textures (our history) are allocated outside of the render graph and imported. A deep dive of render graph is out of scope for this series, please refer to the official docs if you feel uncertain.

URP splits this into two types. We write the pass first, then a thin feature that owns it and exposes inspector fields:

ScriptableRenderPass — enqueued every camera, records into the graph, runs the compute shader.
ScriptableRendererFeature — lives on the URP renderer asset, constructs the pass, enqueues it, disposes it.

In HDRP, RecordRenderGraph is roughly CustomPass.Execute, and the feature is the volume item that owns that pass.

Create a script EntityInfluencePass.cs. Both classes go in this file; start with the pass.

Pass Data#

When writing a pass you generally will end up with a static render function wired up with SetRenderFunc. The reason it has to be static is to avoid any chance of closure allocation (“capture”), and that’s why you need the PassData to store anything you want to pass into such a static function.

1
public class EntityInfoRecordingPass : ScriptableRenderPass
2
{
3
    static readonly int InfluenceTexture = Shader.PropertyToID("_InfluenceTexture");
4

5
    public struct PassDataConstants
6
    {
7
        public int textureSize;
8
        public float pixelToWorldRatio;
9
        public float worldToPixelRatio;
10
    }
11

12
    public class PassData
13
    {
14
        public ComputeShader cs;
15
        public int fadeKernel;
16
        public int transcribeKernel;
17
        public TextureHandle back;
18
        public TextureHandle front;
19
        public BufferHandle buffer;
20
        public GraphicsBuffer rawBuffer;
21
        public NativeArray<EntityInfluenceInfo> stagingBuffer;
22
        public PassDataConstants constants;
23
    }
24
}

TextureHandle / BufferHandle are graph names for the imported resources. rawBuffer is the same GraphicsBuffer as buffer, kept as the native object because SetData is a C# API, not a command-buffer bind. fadeKernel is unused until the Fade section below; declaring it now keeps PassData stable.

Allocating Persistent GPU Resources#

These allocations outlive a single frame. Add the fields, constructor, and allocator to EntityInfoRecordingPass. The constructor arguments (texSize, maxEntityCount, coverageSize) are the inspector exposed values the feature will pass in later.

1
private ComputeShader _cs;
2
private RTHandle _back;
3
private RTHandle _front;
4
private GraphicsBuffer _buffer;
5
private NativeArray<EntityInfluenceInfo> _stagingBuffer;
6
private bool _isFrontTextureBack;
7
private PassDataConstants _constants;
8

9
public EntityInfoRecordingPass(ComputeShader cs, int texSize, int maxEntityCount, float coverageSize)
10
{
11
    _cs = cs;
12
    _constants.textureSize = texSize;
13
    _constants.pixelToWorldRatio = coverageSize / texSize;
14
    _constants.worldToPixelRatio = texSize / coverageSize;
15
    renderPassEvent = RenderPassEvent.BeforeRendering;
16
    EnsureResources(maxEntityCount);
17
}
18

19
private void EnsureResources(int maxEntityCount)
20
{
21
    _stagingBuffer = new NativeArray<EntityInfluenceInfo>(maxEntityCount, Allocator.Persistent);
22
    _buffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, maxEntityCount, EntityInfluenceInfo.Size);
23

24
    var descriptor = new RenderTextureDescriptor(
25
        _constants.textureSize,
26
        _constants.textureSize,
27
        GraphicsFormat.R16G16B16A16_SFloat,
28
        0);
29

30
    descriptor.msaaSamples = 1;
31
    descriptor.enableRandomWrite = true;
32
    descriptor.useMipMap = false;
33
    descriptor.autoGenerateMips = false;
34

35
    RenderingUtils.ReAllocateHandleIfNeeded(
36
        ref _front, descriptor, FilterMode.Point, TextureWrapMode.Clamp,
37
        name: "_InfluenceTextureFront");
38

39
    RenderingUtils.ReAllocateHandleIfNeeded(
40
        ref _back, descriptor, FilterMode.Point, TextureWrapMode.Clamp,
41
        name: "_InfluenceTextureBack");
42
}
43

44
public void Dispose()
45
{
46
    _front.Release();
47
    _back.Release();
48
    _buffer.Dispose();
49
    _stagingBuffer.Dispose();
50
}

A few details:

_isFrontTextureBack controls which texture is considered front texture. This flag is flipped every frame.
enableRandomWrite = true is required for RWTexture2D UAVs.
GraphicsFormat.R16G16B16A16_SFloat is the half4 layout from part 2.
TextureWrapMode.Clamp plus an explicit out-of-bounds path in Fade (coming later) keeps the window edge from wrapping history from the opposite side of the map.
Allocator.Persistent on the staging array: lives as long as the pass is alive.
Dispose is called by the renderer feature to release all the resources.

Recording: Import, Ping-Pong, Set Render Function#

Recording does not upload entity data and does not dispatch. It tells the graph which textures this pass will touch and which callback to run.

Notice how _isFrontTextureBack flips the front and back textures: this frame, _front is the UAV we write and _back is history; next frame the binding swaps. After the pass, the texture we wrote this frame is published as the global _InfluenceTexture so Shader Graph / vertex shaders can sample it.

1
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
2
{
3
    if (!EntityInfluenceManager.Instance.HasCenter) return;
4
    using var builder = renderGraph.AddComputePass<PassData>(
5
        "Influence Texture Update",
6
        out var passData);
7

8
    var front = renderGraph.ImportTexture(_front);
9
    var back = renderGraph.ImportTexture(_back);
10
    var buffer = renderGraph.ImportBuffer(_buffer);
11
    passData.cs = _cs;
12
    passData.transcribeKernel = _cs.FindKernel("Transcribe");
13

14
    passData.back = _isFrontTextureBack ? front : back;
15
    passData.front = _isFrontTextureBack ? back : front;
16
    passData.buffer = buffer;
17
    passData.rawBuffer = _buffer;
18
    passData.constants = _constants;
19
    passData.stagingBuffer = _stagingBuffer;
20

21
    builder.UseTexture(back);
22
    builder.UseTexture(front, AccessFlags.Write);
23
    builder.UseBuffer(buffer);
24
    builder.AllowPassCulling(false);
25

26
    builder.SetGlobalTextureAfterPass(_isFrontTextureBack ? back : front, InfluenceTexture);
27

28
    builder.SetRenderFunc<PassData>(Render);
29

30
    _isFrontTextureBack = !_isFrontTextureBack;
31
}

NOTE: you can see there’s an obvious optimization: move the FindKernel to the constructor as there’s no reason the kernel id would change.

The Render Function#

Once again,Render is static to avoid closure allocations. You can perfectly write a non-static render function but if you have any memory allocation linting, you could see “capture of …”, which isn’t free. We also call the manager’s update function here to avoid any timing issues:

1
private static void Render(PassData data, ComputeGraphContext ctx)
2
{
3
    var cnt = EntityInfluenceManager.Instance.Update(data.stagingBuffer);
4
    var centerDisplacement = EntityInfluenceManager.Instance.CenterDisplacement * data.constants.worldToPixelRatio;
5
    var center = EntityInfluenceManager.Instance.Center;
6
    var halfSize = data.constants.pixelToWorldRatio * data.constants.textureSize / 2;
7
    data.rawBuffer.SetData(data.stagingBuffer);
8

9
    ctx.cmd.SetComputeVectorParam(data.cs, "_InfluenceTextureParams",
10
        new Vector4(data.constants.pixelToWorldRatio, data.constants.textureSize, center.x - halfSize, center.y - halfSize));
11
    ctx.cmd.SetComputeVectorParam(data.cs, "_CenterMotion", new Vector4(
12
        EntityInfluenceManager.Instance.Dt, 0, centerDisplacement.x, centerDisplacement.y
13
    ));
14

15
    var group = Mathf.CeilToInt(data.constants.textureSize / 8f);
16

17
    ctx.cmd.SetComputeBufferParam(data.cs, data.transcribeKernel, "_InfluenceInfo", data.rawBuffer);
18
    ctx.cmd.SetComputeIntParam(data.cs, "_InfluenceInfoCount", cnt);
19
    ctx.cmd.SetComputeTextureParam(data.cs, data.transcribeKernel, "_InfluenceTextureFront", data.front);
20
    ctx.cmd.DispatchCompute(data.cs, data.transcribeKernel, group, group, 1);
21
}

A reminder of what the magic vectors mean:

_InfluenceTextureParams

Component	Value	Used as
x	`coverageSize / texSize`	world units per pixel (`PixelToWorldPos`)
y	`texSize`	integer bounds check in `Transcribe`
zw	`center.xz - halfSize`	lower-left origin of the coverage square

_CenterMotion

Component	Value	Used as
x	`Dt`	elapsed-time increment in Fade
y	unused	—
zw	world XZ delta * `texSize / coverageSize`	history shift, in pixels

Renderer Feature: Inspector and Lifetime#

With all the hard work done we only need the renderer feature to finally wire up the pass in the render pipeline.

1
public class EntityInfoRecordingFeature : ScriptableRendererFeature
2
{
3
    [SerializeField] private ComputeShader computeShader;
4
    public int influenceTextureSize = 512;
5
    public int maxEntityCount = 256;
6
    public float coverageSize = 128;
7
    private EntityInfoRecordingPass _pass;
8

9
    public override void Create()
10
    {
11
        if (computeShader == null) return;
12
        _pass = new EntityInfoRecordingPass(computeShader, influenceTextureSize, maxEntityCount, coverageSize);
13
    }
14

15
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
16
    {
17
        if (_pass != null) renderer.EnqueuePass(_pass);
18
    }
19

20
    protected override void Dispose(bool disposing)
21
    {
22
        _pass.Dispose();
23
    }
24
}

Add this renderer feature to the URP renderer asset, assign the compute shader, set other fields to appropriate values depending on your world size and precision requirements.

Debugging#

Let’s setup a simple shader to visualize our influence texture:

alt text{caption=EIR visualizer}

It samples the global texture _InfluenceTexture, and that’s it. Remember to set the scope of the influence texture parameter to Global or else it won’t work.

Create a material from this shader, add an UI Image and assign the image with the material created.

Now create an empty object and add an EntityInfluenceCenter and a EntityInfluenceProvider nearby. You should see something like this:

alt text{caption=EIR visualizer result}

Drag around the objects to see the non-center object leaving behind a trail. The center object, however, should always stay static — it is glued to the middle of the coverage window.

At this point Fade is not running yet, so trails do not age. Transcribe writes A = 0 under entities and never touches the rest of the texture. Next we will finally implement the fade kernel.

The Fade Kernel#

The fade logic is actually very easy, read elapsed time, and add Dt to it. The complexity comes from the moving center.

If the window origin moved by dx world units, a world point that used to live at pixel p now lives at p - dx / pixelSize. Equivalently, to fill current pixel p we read last frame at p + centerDisplacement (n.b. displacement is already in texel space).

If we ever find the history pixel is outside of the texture, we treat it as a neutral value (effectively when it converge to rest position). Here, 6000 seconds in alpha is far past any visible pendulum.

1
#define NEUTRAL_VALUE half4(0, 0, 0, 6000);
2

3
half4 SampleClamped(RWTexture2D<half4> tex, int2 px)
4
{
5
    uint w, h;
6
    tex.GetDimensions(w, h);
7
    if (px.x < 0 || px.y < 0 || px.x >= w || px.y >= h) return NEUTRAL_VALUE;
8
    return tex[px];
9
}
10

11
half4 SampleNearest(RWTexture2D<half4> tex, int2 current, float2 centerDisplacement)
12
{
13
    return SampleClamped(tex, (int2)round(current + centerDisplacement));
14
}

And then the kernel:

1
#pragma kernel Fade
2
[numthreads(8,8,1)]
3
void Fade(uint3 id: SV_DispatchThreadID)
4
{
5
    uint2 px = id.xy;
6
    uint  width, height;
7
    _InfluenceTextureFront.GetDimensions(width, height);
8
    if (px.x >= width || px.y >= height) return;
9
    float2 centerDisplacement = _CenterMotion.zw;
10
    half4 lastFrameData = SampleNearest(_InfluenceTextureBack, px, centerDisplacement);
11
    half t = lastFrameData.w;
12
    t += _CenterMotion.x;
13
    _InfluenceTextureFront[px] = half4(lastFrameData.xyz, t);
14
}

Update the Dispatch Code#

Recording already imported both textures. We only need the kernel index and, in Render, a bind + dispatch before Transcribe.

Replace RecordRenderGraph and Render with the versions below:


11 collapsed lines
1
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
2
{
3
    if (!EntityInfluenceManager.Instance.HasCenter) return;
4
    using var builder = renderGraph.AddComputePass<PassData>(
5
        "Influence Texture Update",
6
        out var passData);
7

8
    var front = renderGraph.ImportTexture(_front);
9
    var back = renderGraph.ImportTexture(_back);
10
    var buffer = renderGraph.ImportBuffer(_buffer);
11
    passData.cs = _cs;
12
    passData.transcribeKernel = _cs.FindKernel("Transcribe");
13
    passData.fadeKernel = _cs.FindKernel("Fade");
14

18 collapsed lines
15
    passData.back = _isFrontTextureBack ? front : back;
16
    passData.front = _isFrontTextureBack ? back : front;
17
    passData.buffer = buffer;
18
    passData.rawBuffer = _buffer;
19
    passData.constants = _constants;
20
    passData.stagingBuffer = _stagingBuffer;
21

22
    builder.UseTexture(back);
23
    builder.UseTexture(front, AccessFlags.Write);
24
    builder.UseBuffer(buffer);
25
    builder.AllowPassCulling(false);
26

27
    builder.SetGlobalTextureAfterPass(_isFrontTextureBack ? back : front, InfluenceTexture);
28

29
    builder.SetRenderFunc<PassData>(Render);
30

31
    _isFrontTextureBack = !_isFrontTextureBack;
32
}

1
private static void Render(PassData data, ComputeGraphContext ctx)
2
{
5 collapsed lines
3
    var cnt = EntityInfluenceManager.Instance.Update(data.stagingBuffer);
4
    var centerDisplacement = EntityInfluenceManager.Instance.CenterDisplacement * data.constants.worldToPixelRatio;
5
    var center = EntityInfluenceManager.Instance.Center;
6
    var halfSize = data.constants.pixelToWorldRatio * data.constants.textureSize / 2;
7
    data.rawBuffer.SetData(data.stagingBuffer);
8

9
    ctx.cmd.SetComputeVectorParam(data.cs, "_InfluenceTextureParams",
10
        new Vector4(data.constants.pixelToWorldRatio, data.constants.textureSize, center.x - halfSize, center.y - halfSize));
11
    ctx.cmd.SetComputeVectorParam(data.cs, "_CenterMotion", new Vector4(
12
        EntityInfluenceManager.Instance.Dt, 0, centerDisplacement.x, centerDisplacement.y
13
    ));
14
    ctx.cmd.SetComputeTextureParam(data.cs, data.fadeKernel, "_InfluenceTextureBack", data.back);
15
    ctx.cmd.SetComputeTextureParam(data.cs, data.fadeKernel, "_InfluenceTextureFront", data.front);
16

17
    var group = Mathf.CeilToInt(data.constants.textureSize / 8f);
18
    ctx.cmd.DispatchCompute(data.cs, data.fadeKernel, group, group, 1);
19

4 collapsed lines
20
    ctx.cmd.SetComputeBufferParam(data.cs, data.transcribeKernel, "_InfluenceInfo", data.rawBuffer);
21
    ctx.cmd.SetComputeIntParam(data.cs, "_InfluenceInfoCount", cnt);
22
    ctx.cmd.SetComputeTextureParam(data.cs, data.transcribeKernel, "_InfluenceTextureFront", data.front);
23
    ctx.cmd.DispatchCompute(data.cs, data.transcribeKernel, group, group, 1);
24
}

Update the visualizer:

alt text{caption=EIR visualizer with fade}

You can set the dividend to any value you like. A higher value allows you to see a longer duration.

Drag around, trails should now fade toward rest as you walk away, and stay glued to world space as the center moves.

But, if you move the center very slowly, you may notice something peculiar:

The other entity, which hasn’t moved, is leaving behind a trail!

This is due to the SampleNearest function we wrote. In that function, we used the round function. Imagine if the history texel is between two texels, one is with data and the other is a neutral value. If we are only slightly on the non-neutral side then round function tells us that we must pick the non-neutral value as history. This causes the value to “leak” to other texels and the error would accumulate. “Moving Slowly” makes this accumulation more evident. This class of error is referred to as Quantization Error.

Addressing the Quantization Error#

The standard way to mitigate/reduce the quantization error is to use Bilinear Filtering (or any filtering you like). Here, instead of picking one pixel, we pick the neighboring 4 pixels, and weight the contribution using the fraction from the nearest sampling. Add the following function and replace SampleNearest with SampleBilinearFractionWeighted:

1
half4 SampleBilinearFractionWeighted(RWTexture2D<half4> tex, int2 current, float2 centerDisplacement)
2
{
3
    float2 p = float2(current) + centerDisplacement;
4
    int2   base = int2(floor(p));
5
    float2 f = frac(p);
6
    half4  s00 = SampleClamped(tex, base);
7
    half4  s10 = SampleClamped(tex, base + int2(1, 0));
8
    half4  s01 = SampleClamped(tex, base + int2(0, 1));
9
    half4  s11 = SampleClamped(tex, base + int2(1, 1));
10
    float  w00 = (1.0 - f.x) * (1.0 - f.y);
11
    float  w10 = f.x * (1.0 - f.y);
12
    float  w01 = (1.0 - f.x) * f.y;
13
    float  w11 = f.x * f.y;
14
    return half4(s00 * w00 + s10 * w10 + s01 * w01 + s11 * w11);
15
}

Now redo the same experiment, the error may still be visible, but no way as prominent as previously seen, and should be largely invisible in actual runtime. Also, you can see the trail of the center has improved as well, it was suffering from the same quantization error and failed to produce visible trails.

This concludes our preparation work, and in the final part we will implement the vertex shader.