At Rest (Initial Angle)#

Recall in Part 1: $\theta_0(d) = \frac{\pi}{2}-arctan(\frac{2h_0d}{R_0^2-d^2})$

For initial angle calculation, we need the height $h_0$ and radius $R_0$ of the instigator, which are simply 2 tweakable floats.

As for $d$, by definition, is the top-down view distance between the center of the instigator (therefore, instigator’s transform position’s xz components), and the root of the grass. We can treat all grass that fall within the same pixel as having the same root position, then the grass root position is simply converting pixel coordinates to its equivalent world position. As you can see, the resolution of the texture decides how many grass patches are moving in the same way. You could eventually do interpolation using the fraction, but for simplicity we leave it out in this series.

In Motion#

The motion equation we established in the first part gives the angle. We will be implementing the most interesting underdamped case in this series, but feel free to implement other cases.

For each vertex:

$\theta(t)=\theta_0*e^{-\gamma t}cos(\omega t)$

Where:

• $\gamma=\frac{b}{2*l_0}$
• $\omega_0 = \sqrt{\frac{g-k}{l_0}}$
• $\omega = \sqrt{abs(\gamma^2-\omega_0^2)}$

We need grass length $l_0$, elasticity constant $k$, damping coefficient $b$, and elapsed time $t$. The length, elasticity constant, and damping coefficient are all grass-specific constants that can be exposed as material properties, that leaves us with elapsed time which is a runtime variable. The definition of elapsed time, in our case, is the time when grass leaves the influence of an entity. We have 2 methods:

1. Store the timestamp t when the grass is last in an entity’s influence, then in the vertex shader, we can calculate the elapsed time with _Time.y - t.
2. Store the elapsed time dt directly. Each frame we increase the elapsed time dt by unity_DeltaTime.x, and set dt = 0 if the grass is in any entity’s influence.

They are both valid, but method 1 comes with a problem: your data type must be large enough to store the timestamp. Consider if using half, then your maximum timestamp is 65504, around 18 hours (which is ok if the player isn’t a marathon streamer), and the precision will get significantly worse when moving toward the limit. So we will adopt method 2 as a large elapsed time would make no visual difference compared to the rest position, and we could clamp it to avoid the overflow issue.

Texture Update Logic#

Let’s tackle the part in common first: Given a pixel and an entity, does the pixel falls into the entity’s influence?

The logic is simple, since pixel is in texture space, and entity position is in world space, we need to compare them in the same space.

• If we compare in pixel, we need to convert entity’s position and its radius to pixel.
• If we compare in world units, we need to convert pixel’s position to world space.

The latter requires one less conversion and has better precision so we will compare them in world units:

$PixelWorldPos = TextureOriginWS + PixelCoord*PixelToWorldRatio$

And if the pixel is in the entity’s influence, then its distance to the entity must be smaller than the entity’s radius.

1
half2 PixelToWorldPos(in uint2 px)
2
{
3
    half  ratio  = _InfluenceTextureParams.x;
4
    half2 offset = _InfluenceTextureParams.zw;
5
    return offset + px * ratio;
6
}
7

8
bool IsPixelInInfluence(in half2 pxWorldPos, in InfluenceInfo entity)
9
{
10
    return distance(pxWorldPos, entity.worldPosition.xz) < entity.radius;
11
}

We separate the conversion and the check because later we will also need to use the pixel’s world position. We could convert once and reuse the result in other function calls.

The next question is, if we found a pixel in an entity’s influence, how do we update its color values?

• For A channel, we need to reset the elapsed time to 0 as the entity’s influence will cause the grass to be in a static state.
• For RG (normalized direction), we calculate the displacement from the entity’s center to the pixel, in world space.
• For the B channel, we calculate via: $elevation = entityY-h_0+h(d)$ for the bottom surface elevation.
• For the magnitude of RG (initial angle), we will simply apply the formula we saw in part 1 of the series to calculate the initial angle.

1
#define HALF_PI 1.5707963
2

3
half EllipticElevation(half x2, half a2, half b)
4
{
5
    return b * (sqrt(max(0, 1 - x2 / a2)) + 1);
6
}
7

8
void UpdateInfluence(in uint2 px, in half2 pxWorldPos, in InfluenceInfo entity)
9
{
10
    half2 displacement = pxWorldPos - entity.worldPosition.xz;
11
    half  d  = length(displacement);
12
    half  R2 = entity.radius * entity.radius;
13
    half  h  = entity.height;
14
    half  d2 = d * d;
15

16
    // calculate initial angle
17
    half initialAngle = HALF_PI - atan(2 * entity.height * d / max(R2 - d2, 0.00001));
18

19
    // calculate elevation
20
    half entityElevation = entity.worldPosition.y - EllipticElevation(d2, R2, h);
21
    _InfluenceTextureFront[px] = half4(normalize(displacement) * max(0.01, initialAngle), entityElevation, 0);
22
}

You might notice that the velocity of the entity is not used… well, it is indeed not covered in this series but you may want to use it for a more believable simulation. For instance, the grass blade may not always bend following the radial vector, it may also follow the entity’s motion direction due to friction.

max(R2 - d2, 0.00001) is the division-by-zero guard from part 1: at $d = R_0$ the tangent slope is infinite. max(0.01, initialAngle) keeps the stored direction from collapsing to a zero vector when the angle is tiny (normalization in the vertex shader would then blow up).

NOTE: Strictly speaking, setting time to 0 will actually cause grass blade to “teleport” to the target position. You could try to lerp the time to 0, essentially “reverse” the motion. But that would look particularly weird when the grass is underdamped.

Transcription Kernel#

Since we have tackled the hard part, the kernel itself becomes straightforward. One thread per pixel, skip anything outside the square, then walk entities until the first hit:

1
#pragma kernel Transcribe
2
[numthreads(8,8,1)]
3
void Transcribe(uint3 id: SV_DispatchThreadID)
4
{
5
    uint2 px = id.xy;
6
    if (px.x >= _InfluenceTextureParams.y || px.y >= _InfluenceTextureParams.y) return;
7
    // Iterate over each entity
8
    for (int i = 0; i < _InfluenceInfoCount; i++)
9
    {
10
        InfluenceInfo info = _InfluenceInfo[i];
11
        half2 thisPxWsPos = PixelToWorldPos(px);
12
        if (IsPixelInInfluence(thisPxWsPos, info))
13
        {
14
            UpdateInfluence(px, thisPxWsPos, info);
15
            return;
16
        }
17
    }
18
}

[numthreads(8,8,1)] is a comfortable default for a 2D UAV: 64 threads per group, and the CPU dispatch will use ceil(textureSize / 8) groups on each axis. Pixels past the edge of a non-multiple-of-8 size are rejected by the bounds check.

The early return after a hit means overlapping entities are first-in-buffer-wins. That is good enough for this series; a later refinement could pick the closest entity, or the one with the largest initial angle, or even accumulate forces if you wish.

The compute shader so far:

1
struct InfluenceInfo
2
{
3
    float3 worldPosition;
4
    float  radius;
5
    float3 worldVelocity;
6
    float  height;
7
};
8

9
StructuredBuffer<InfluenceInfo> _InfluenceInfo;
10
int _InfluenceInfoCount;
11

12
RWTexture2D<half4> _InfluenceTextureBack;
13
RWTexture2D<half4> _InfluenceTextureFront;
14

15
float4 _InfluenceTextureParams;
16
float4 _CenterMotion;
17

18
half2 PixelToWorldPos(in uint2 px)
19
{
20
    half  ratio  = _InfluenceTextureParams.x;
21
    half2 offset = _InfluenceTextureParams.zw;
22
    return offset + px * ratio;
23
}
24

25
bool IsPixelInInfluence(in half2 pxWorldPos, in InfluenceInfo entity)
26
{
27
    return distance(pxWorldPos, entity.worldPosition.xz) < entity.radius;
28
}
29

30
#define HALF_PI 1.5707963
31

32
half EllipticElevation(half x2, half a2, half b)
33
{
34
    return b * (sqrt(max(0, 1 - x2 / a2)) + 1);
35
}
36

37
void UpdateInfluence(in uint2 px, in half2 pxWorldPos, in InfluenceInfo entity)
38
{
39
    half2 displacement = pxWorldPos - entity.worldPosition.xz;
40
    half  d  = length(displacement);
41
    half  R2 = entity.radius * entity.radius;
42
    half  h  = entity.height;
43
    half  d2 = d * d;
44

45
    half initialAngle = HALF_PI - atan(2 * entity.height * d / max(R2 - d2, 0.00001));
46
    half entityElevation = entity.worldPosition.y - EllipticElevation(d2, R2, h);
47
    _InfluenceTextureFront[px] = half4(normalize(displacement) * max(0.01, initialAngle), entityElevation, 0);
48
}
49

50
#pragma kernel Transcribe
51
[numthreads(8,8,1)]
52
void Transcribe(uint3 id: SV_DispatchThreadID)
53
{
54
    uint2 px = id.xy;
55
    if (px.x >= _InfluenceTextureParams.y || px.y >= _InfluenceTextureParams.y) return;
56
    for (int i = 0; i < _InfluenceInfoCount; i++)
57
    {
58
        InfluenceInfo info = _InfluenceInfo[i];
59
        half2 thisPxWsPos = PixelToWorldPos(px);
60
        if (IsPixelInInfluence(thisPxWsPos, info))
61
        {
62
            UpdateInfluence(px, thisPxWsPos, info);
63
            return;
64
        }
65
    }
66
}

In the next part we will set up the driver code, wire this kernel through a URP renderer feature, and verify the entity transcription actually works. The Fade kernel — the reason we allocated two textures and _CenterMotion — lands in that same part.