Procedural grass rendering

Growing one blade of grass

Each blade of grass has a position bladePosition, direction bladeDirection and a height bladeHeight. We use these to calculate the control points P_0, P_1 and P_2 of a quadratic Bézier curve to represent the shape of a blade of grass.

const static float grassLeaning = 0.3f;
float3 p0 = bladePosition;
float3 p1 = p0 + float3(0, 0, bladeHeight);
float3 p2 = p1 + bladeDirection * bladeHeight * grassLeaning;

P_0 is simply bladePosition. P_1 is P_0 translated upwards by bladeHeight h. To obtain P_2, we translate P_1 by the bladeDirection vector \vec{d} scaled with bladeHeight times a leaning factor of grassLeaning = 0.3. This preserves the shape of the blade of grass, regardless of its bladeHeight.

To animate the grass we move P_2, which modifies the length of the Bézier curve. To preserve the length of the curve, we use a function to modify P_1 and P_2 to retain the length of the curve, using the function from Jahrmann and Wimmer.

MakePersistentLength(p0, p1, p2, bladeHeight);      //Function body in the appendix

A width w for each control point defines the width of the grass blade. To apply the width, we translate each control point outwards by length w using the perpendicular vector of our bladeDirection. The new projected control points are called P_0^-,P_0^+,P_1^-,P_1^+,P_2^- and P_2^+. All positive P^+ form a blade edge, and all negative P^- form the other one. Thus, we now have two Bézier curves representing the edges of the grass blade as can be seen in the following figure:

Bézier to triangles

To create geometry, we evaluate each of our two edge curves n=4 times. Thus we get 4 vertices per blade edge, or 8 vertices in total. A Bézier curve can be evaluated as follows:

float3 bezier(float3 p0, float3 p1, float3 p2, float t)
{
    float3 a = lerp(p0, p1, t);
    float3 b = lerp(p1, p2, t);
    return lerp(a, b, t);
}

Connecting these |V|=8 vertices results in |T|=6 triangles.

Assuming a counter-clockwise winding order, this results in the following primitives:

To perform shading, we calculate the normal vectors, depending on the derivative of the Bézier curve:

float3 bezierDerivative(float3 p0, float3 p1, float3 p2, float t)
{
    return 2. * (1. - t) * (p1 - p0) + 2. * t * (p2 - p1);
}

To get the normal vector, we first need to calculate a normalized vector perpendicular to the bladeDirection. We then calculate the cross product between this sideVec and the derivative at the current interpolation parameter t.

float3 sideVec = normalize(float3(bladeDirection.y, -bladeDirection.x, 0)); 
float3 normal  = cross(sideVec, normalize(bezierDerivative(p0, p1, p2, t)));

Combining grass blades to a grass patch

One mesh shader work group generates the geometry for one patch of grass. A patch of grass has the following arguments:

struct GrassPatchArguments {
    float3 patchPosition;
    float3 groundNormal;
    float  height;
};

We assume the buffer of GrassPatchArguments as given. We access the buffer at the index of gid, with gid being the SV_GroupID of our thread group. We randomly scatter the blades of grass in a circle around patchPosition. Since the ground we place the grass on typically is not flat, blades further away from the patchPosition would start floating mid air. To fix this, we require the groundNormal to project the blade scattering circle onto the terrain surface. The variable patchRadius is a global parameter and describes the radius of the scattering circle, thus the maximum distance to the center of the grass patch. To calculate the patchPosition of a blade of grass in a patch, we obtain a random radius r_{\mathrm{blade}} (bladeRadius) and a random angle \alpha (alpha). With these, we can calculate the bladeOffset from the center of the patch patchPosition. Each blade is then rotated with a random angle \beta (beta).

In the following code example, we compute bladeDirection and bladePosition. Note that the function rand(...) provides a seeded and uniformly distributed pseudo-random value between 0 and 1.

    ...
    uint seed = combineSeed(globalSeed, bladeId);

    float beta = 2. * PI * rand(seed);
    float2 bladeDirection = float2(cos(beta), sin(beta));

    float3 tangent = normalize(cross(float3(0,1,0),groundNormal));
    float3 bitangent = normalize(cross(groundNormal, tangent));

    float alpha = 2. * PI * rand(seed);
    float bladeRadius = patchRadius * sqrt(rand(seed));
    float3 bladeOffset = bladeRadius * (cos(alpha) * tangent + sin(alpha) * bitangent);

    float3 bladePosition = patchPosition + bladeOffset;
    ...

We also get a height for the whole patch, which is the mean height of all grass blades of the patch. For a more diverse appearance, we slightly vary the height of each grass blade in a patch:

const float bladeHeight = height + float(rand(seed)) * RAND_HEIGHT_SCALE;

Thread allocation

Since it is specified in the DirectX-Specs that mesh shaders can only output up to 256 vertices, our patch of grass consists of a maximum of \frac{256}{8}=32 blades of grass. We have 6 primitives and 8 vertices per blade. This results in 192 primitives and 256 vertices per patch. Our vertices have the following attributes:

struct Vertex
{
    float4 clipSpacePosition   : SV_POSITION;
    float3 worldSpacePosition  : POSITION0;
    float3 worldSpaceNormal    : NORMAL0;
    float  rootHeight          : BLENDWEIGHT0; //Used for fake self shadow
    float  height              : BLENDWEIGHT1; //Used for fake self shadow
};

To write the index and vertex buffer, we use the best practices described in an earlier blog post of this series Mesh Shader Opimizations and Best Practices. To recap, we set the thread group size to its limit of GROUP_SIZE = 128. We have to make sure that the i-th primitive and the i-th vertex is written by the i-th thread in the thread group. Since our primitive count is greater than the thread group size of 128, we use a thread-group-sided stride of 128. Each thread then calculates a maximum of two vertices and two primitives.

...
for (uint i = 0; i < 2; ++i) {
    int vertId = gtid + GROUP_SIZE * i;

    if(vertId >= vertexCount) break;            //Depends on the number of blades generated    

    int bladeId     = vertId / verticesPerBlade;
    int vertIdLocal = vertId % verticesPerBlade;
    ...

    //vector perpendicular to the blade direction
    float3 sideVec = normalize(float3(bladeDirection.y, -bladeDirection.x, 0)); 
    float3 offset  = tsign(vertIdLocal, 0) * WIDTH_SCALE * sideVec;

    const static float w0 = 1.f;
    const static float w1 = .7f;
    const static float w2 = .3f;

    p0 += offset * w0;
    p1 += offset * w1;
    p2 += offset * w2;

    float t = (vertIdLocal/2) / float(verticesPerBladeEdge - 1);

    Vertex vertex;
    vertex.height             = height;
    vertex.rootHeight         = p0.z;
    vertex.worldSpacePosition = bezier(p0, p1, p2, t);
    vertex.worldSpaceNormal   = cross(sideVec, normalize(bezierDerivative(p0, p1, p2, t)));
    vertex.clipSpacePosition  = mul(DynamicConst.viewProjectionMatrix, float4(vertex.worldSpacePosition, 1));

    verts[vertId] = vertex;
}   //end for-loop
...

for (uint i = 0; i < 2; ++i) {
    int triId = gtid + GROUP_SIZE * i;

    if (triId >= triangleCount) break;

    int bladeId    = triId / trianglesPerBlade;
    int triIdLocal = triId % trianglesPerBlade;

    int offset = bladeId * verticesPerBlade + 2 * (triIdLocal / 2);

    uint3 triangleIndices = (triLocal & 1) == 0? uint3(0, 1, 2) :
                                                 uint3(3, 2, 1);

    tris[triId] = offset + triangleIndices;
}   //end for-loop

Fractional scaling

To hide the transition, we implemented a fractional scaling for the number of grass blades. For this, we introduce two variables bladeCount and its real value version bladeCountF.

...
float bladeCountF = lerp(float(MAX_BLADE_COUNT), 2., saturate(distanceToCamera / GRASS_END_DISTANCE));
int   bladeCount  = ceil(bladeCountF);

if (bladeId == (bladeCount - 1)) {
    width *= frac(bladeCountF);
}
...

All the grass blades with a bladeId smaller than bladeCount-1 are drawn without modification. The width of the last grass blade at bladeId = bladeCount-1 gets scaled with the fractional part of bladeCountF.

Geometry compensation

To keep the visual appearance consistent between every distance from the camera, we modify the width of each grass blade in a patch.

width *= maxBladeCount / bladeCountF;

The animation shows the effect in a greatly exaggerated manner, but in a dense meadow, this effect is barely noticeable.

Full grass mesh shader

int tsign(in uint gtid, in int id) {
    return (gtid & (1u << id)) ? 1 : -1;
}

struct Vertex
{
    float4 clipSpacePosition   : SV_POSITION;
    float3 worldSpacePosition  : POSITION0;
    float3 worldSpaceNormal    : NORMAL0;
    float  rootHeight          : BLENDWEIGHT0;        
    float  height              : BLENDWEIGHT1;
};

static const int GROUP_SIZE       = 128;
static const int GRASS_VERT_COUNT = 256;
static const int GRASS_PRIM_COUNT = 192;

[NumThreads(GROUP_SIZE, 1, 1)]
[OutputTopology("triangle")]
void MeshShader(
    uint gtid : SV_GroupThreadID,
    uint gid : SV_GroupID,
    out indices uint3 tris[GRASS_PRIM_COUNT],
    out vertices Vertex verts[GRASS_VERT_COUNT]
)
{
    const GrassPatchArguments arguments = //Load arguments
    
    SetMeshOutputCounts(GRASS_VERT_COUNT, GRASS_PRIM_COUNT);
	
	static const int verticesPerBladeEdge = 4;
    static const int verticesPerBlade =  2 * verticesPerBladeEdge;
    static const int trianglesPerBlade = 6;
    static const int maxBladeCount = 32;
    
    const float3 patchCenter = arguments.position;
    const float3 patchNormal = arguments.normal;
    const float  spacing     = DynamicConst.grassSpacing;
    const int seed           = combineSeed(asuint(int(patchCenter.x / spacing)), asuint(int(patchCenter.y / spacing)));
	
    float distanceToCamera = distance(arguments.position, DynamicConst.cullingCameraPosition.xyz);
    float bladeCountF      = lerp(float(maxBladeCount), 2., pow(saturate(distanceToCamera / (GRASS_END_DISTANCE * 1.05)), 0.75));
    
    int bladeCount = ceil(bladeCountF);
    
    const int vertexCount   = bladeCount * verticesPerBlade;
    const int triangleCount = bladeCount * trianglesPerBlade;
        
    for (uint i = 0; i < 2; ++i){
        int vertId = gtid + GROUP_SIZE * i;

        if (vertId >= vertexCount) break;
        
        int bladeId     = vertId / verticesPerBlade;        
        int vertIdLocal = vertId % verticesPerBlade;
           
        const float height = arguments.height + float(rand(seed, bladeId, 20)) / 40.;
        
        //position the grass in a circle around the patchPosition and angled using the patchNormal
        float3 tangent   = normalize(cross(float3(0, 1, 0), patchNormal));
        float3 bitangent = normalize(cross(patchNormal, tangent));
             
        float  bladeDirectionAngle = 2. * PI * rand(seed, 4, bladeId);
        float2 bladeDirection      = float2(cos(bladeDirectionAngle), sin(bladeDirectionAngle));
       
        float  offsetAngle  = 2. * PI * rand(seed, bladeId);
        float  offsetRadius = spacing * sqrt(rand(seed, 19, bladeId));
        float3 bladeOffset  = offsetRadius * (cos(offsetAngle) * tangent + sin(offsetAngle) * bitangent);
        
        float3 p0 = patchCenter + bladeOffset;
        float3 p1 = p0 + float3(0, 0, height);
        float3 p2 = p1 + bladeDirection  * height * 0.3;
     
        p2 += GetWindOffset(p0.xy, DynamicConst.shaderTime);
        
        MakePersistentLength(p0, p1, p2, height);
        
        float width = 0.03;
        
        width *= maxBladeCount / bladeCountF;
        
        if (bladeId == (bladeCount-1)){
            width *= frac(bladeCountF);
        }
        
        Vertex vertex;
        vertex.height                 = arguments.height;
        vertex.worldSpaceGroundNormal = arguments.normal;
        vertex.rootHeight             = p0.z;
        
        float3 sideVec = normalize(float3(bladeDirection.y, -bladeDirection.x, 0));
        float3 offset  = tsign(vertIdLocal, 0) * width * sideVec;
        
        p0 += offset * 1.0;
        p1 += offset * 0.7;
        p2 += offset * 0.3;
          
        float t = (vertIdLocal/2) / float(verticesPerBladeEdge - 1);
        vertex.worldSpacePosition = bezier(p0, p1, p2, t);
        vertex.worldSpaceNormal   = cross(sideVec, normalize(bezierDerivative(p0, p1, p2, t)));
        vertex.clipSpacePosition  = mul(DynamicConst.viewProjectionMatrix, float4(vertex.worldSpacePosition, 1));

        verts[vertId] = vertex;
    }

    for (uint i = 0; i < 2; ++i){
        int triId = gtid + GROUP_SIZE * i;

        if (triId >= triangleCount) break;

        int bladeId    = triId / trianglesPerBlade;
        int triIdLocal = triId % trianglesPerBlade;

        int offset = bladeId * verticesPerBlade + 2 * (triIdLocal / 2);

        uint3 triangleIndices = (triLocal & 1) == 0? uint3(0, 1, 2) :
                                                     uint3(3, 2, 1);

        tris[triId] = offset + triangleIndices;
    }   
}

Full pixel shader

struct PixelShaderOutput {
    float3 patchPosition : SV_Target0;
    float4 baseColor : SV_Target1;
    float3 normal : SV_Target2;
};


PixelShaderOutput GrassPatchPixelShader(const Vertex input, bool isFrontFace : SV_IsFrontFace)
{
    PixelShaderOutput output;
    output.position = input.worldSpacePosition;
    	
    float selfshadow = clamp(pow((input.worldSpacePosition.y - input.rootHeight)/input.height, 1.5), 0, 1);
    output.baseColor.rgb = pow(float3(0.41, 0.44, 0.29), 2.2) * selfshadow;
    output.baseColor.rgb *= 0.75 + 0.25 * PerlinNoise2D(0.25 * input.worldSpacePosition.xy);
    output.baseColor.a = 1;
    
    float3 normal = normalize(input.worldSpaceNormal);

    if (!isFrontFace) {
        normal = -normal;
    }

    output.normal.xyz = normalize(lerp(float3(0, 0, 1), normal, 0.25));

    return output;
}

Make persistent length

MakePersistentLength Source

void MakePersistentLength(in float3 v0, inout float3 v1, inout float3 v2, in float height)
{
    //Persistent length
    float3 v01 = v1 - v0;
    float3 v12 = v2 - v1;
    float lv01 = length(v01);
    float lv12 = length(v12);

    float L1 = lv01 + lv12;
    float L0 = length(v2-v0);
    float L = (2.0f * L0 + L1) / 3.0f; //http://steve.hollasch.net/cgindex/curves/cbezarclen.html

    float ldiff = height / L;
    v01 = v01 * ldiff;
    v12 = v12 * ldiff;
    v1 = v0 + v01;
    v2 = v1 + v12;
}