Emulating Ghost of Tsushima's Grass in Godot

The game world is tiled, with each tile containing an instance of multiple grass blade meshes via GPU instancing, using a single draw call to instantiate all instances of the blade mesh within the tile. Every blade of grass bends with respect to an artist authored bezier curve and has a unique random offset to its position, orientation, scale, and bend. Then, the wind strength and direction at the blade’s position is sampled from the game’s wind system to modify the blade’s bend and orientation. They also implemented a “clumping” system where nearby grass blades belonging to the same “clump” obtain similar random properties for all of the above parameters. Each grass blade “type” is artist authored and includes separate vein and stem albedo, gloss, and normal textures which round the edges of the grass blade to give it a more realistic appearance. For performance, the blade meshes are assigned one of two LOD models and are view frustum culled.

I built this in Godot 4.5, using its graphics pipeline and FastNoiseLite library. The setup is pretty simple: a light source and camera attached to the root node, a script, and a material asset for the grass shader.

A mesh is the shape of a 3D object, built from points (vertices) connected into triangles. Here, it’s a single blade of grass. A draw call is a command telling the graphics processor to draw something. GPU instancing uses one single draw call to draw the same shape many times with different positions, sizes, and rotations.

A shader is a small program that runs on the graphics processor. A vertex shader moves the points that make up each blade, so it handles bending and rotation. A fragment shader decides what color the blade’s surface should be at each visible point.

A noise texture is a texture with randomized values. Each kind of noise texture has useful properties which vary depending on the generation technique. Making every pixel a random (0, 1] value is often referred to as static or white noise, for example.

I implement all of this in the vertex shader.

I sample the Perlin noise texture (or “wind texture”) at coordinates $s_0$, using elapsed time $t$ in seconds, wind speed $w_s$ (default 1.0), and the blade’s ground-plane position $\mathrm{pos}_{\mathrm{world}}$ (world-space x and z). The constant $c_d$ scales the sampling coordinates:

I multiply the sampled value by $\pi/2$ to get the wind angle $w_\theta$. Increasing $w_s$ makes the wind texture scroll faster. I used $0.005$ for $c_d$. I compute the blade’s initial rotation angle $\theta_0$ using its repeatable position-based hash $x_p$ and the sampled clump value $x_c$, both in $[0,1]$. Here, $\tau=2\pi$ is a full turn in radians:

I also sample a wind strength $w_f$ from the wind texture at $s_0$ and multiply it by a factor of $4/5$. I blend these into the final rotation angle $\theta$, using $\operatorname{mix}(a,b,u)=(1-u)a+ub$:

This angle is used to generate a rotation matrix about the y-axis $M_r$.

I use the relative height of the vertex $h=1-\mathrm{UV}_y$, from 0 at the base to 1 at the tip, to compute an initial bend angle $\beta_0$. The variation value $x=(1-c)x_p+cx_c$ combines the blade hash and clump value with clumping weight $c=0.8$:

I then sample the wind texture at a second set of coordinates $s_1$. Here, $t_h=t+0.25h^2$ offsets the time farther along the blade. The temporal sampling factor is 0.05, while the spatial factor remains $c_d=0.005$:

I call the value sampled here $w_b$. I remap it from $[0,1]$ to $[0.25,1]$ and square it, then multiply by wind speed and a bend variation factor $q$. That factor blends a fixed value with the blade’s hash using the clump value:

The remapped strength produces the final bend angle $\beta$:

This matches the shader’s mix(0, PI, wind_strength_bend), since blending from zero to $\pi$ is just multiplication by $\pi$. The angle generates a rotation matrix about the x-axis, $M_b$. The height-dependent offset puts the blade tips ahead in the wind texture; the additional wind bend itself has no extra $h^2$ multiplier.

Finally, I apply both rotation matrices to the vertex position $\boldsymbol{v}$ and the normal:

to properly rotate and bend the blade mesh.

Unless otherwise mentioned, I picked the constants by experimenting and seeing what looked good.

I use the blade’s world position to generate a hash value $x_p$ in $[0,1]$ and sample the cellular noise texture (or “clump texture”) to get a value $x_c$ in $[0,1]$. I combine these into a variation parameter $x$, using the clumping weight $c$ (set to 0.8). At $c=0$, each blade uses only its own random value; at $c=1$, it uses only the clump texture:

that I use to scale the blade mesh’s vertex. I scale the vertex’s local horizontal coordinate $v_x$ and vertical coordinate $v_y$ with the following expressions. The function $\operatorname{mix}(a,b,u)=(1-u)a+ub$ blends between two values:

for width and height variation.

The normal vector at a point on a mesh is the vector perpendicular to the surface. Lighting uses it to work out how the surface faces the light. By varying that direction across a flat blade, we can make the lighting behave as if the blade were curved.

In the vertex shader I compute leftward and rightward facing normals by rotating the normal about the y-axis by $c_n\pi$ and $-c_n\pi$, respectively. The curvature parameter $c_n$ corresponds to normal_curve_factor in the shader, with a default of 0.3 and a range of 0 to 0.5; multiplying by $\pi$ gives an angle in radians. I pass these to the fragment shader and interpolate between them using the fragment’s horizontal coordinate $\mathrm{UV}_x$, which runs across the blade. This makes the flat blades look rounded.

The fragment shader uses the specified base color $\boldsymbol{b}$ and tip color $\boldsymbol{b}^{\prime}$ to color every blade of grass. I also color distant fragments closer to the average color to simulate blending at far distances.

I set the albedo using relative height $h=1-\mathrm{UV}_y$, from base (0) to tip (1). The function $\operatorname{mix}(a,b,u)=(1-u)a+ub$ blends between colors:

Here, $\boldsymbol{v}$ is the fragment position in view space, so $\lVert\boldsymbol{v}\rVert$ is its distance from the camera. The constant 0.04 controls how quickly the distant color takes over, and $e$ is the base of the natural exponential. The divisor 4 is the shader’s chosen distant-color factor, rather than a literal average of the two colors.

Ambient occlusion approximates how nearby surfaces block light from reaching each other. The bases of densely packed grass get less light than the exposed tips. Here, I approximate that with the grass density and the height along the blade in the lighting function (light()).

I emulate ambient occlusion using grass density $d$ and relative height $h=1-\mathrm{UV}_y$, from base to tip. The occlusion factor $o$ darkens the base more as density increases. Using $\operatorname{mix}(a,b,u)=(1-u)a+ub$, I set it as

I then set the diffuse lighting color to

Here, $\boldsymbol{\alpha}$ is Godot’s light attenuation (ATTENUATION), $\boldsymbol{l}_c$ is the light color (LIGHT_COLOR), $\boldsymbol{n}$ is the surface normal (NORMAL), and $\boldsymbol{l}$ is the direction toward the light (LIGHT). The dot product $\boldsymbol{n}\cdot\boldsymbol{l}$ measures how directly the surface faces the light. This gives a result I’m happy with.

View frustum culling skips objects outside the camera’s view. LOD (level of detail) switching uses simpler versions of objects farther away, where the extra detail is harder to see.