SimpleGrassTextured: painting grass onto Godot 4 terrain

A plugin you copy into res://addons, not a package you install

SimpleGrassTextured is a plugin for Godot 4 that allows you to add grass and plants to your scene in a simple way, and it is written in GDScript.

There are two installation routes and they are equally manual in spirit. Through the AssetLib, you open the AssetLib tab in Godot, search for Simple Grass Textured, install the plugin, and then enable SimpleGrassTextured in Project, then Project Settings, then Plugins. The manual route is to clone or download the repository, copy the folder addons/simplegrasstextured into your own res://addons/ folder, and enable it in the same place. The project is also published on itch.io at icterusgames.itch.io/simple-grass-textured.

The repository itself is small, which tells you what kind of thing this is. The top level holds a .gitattributes, a .gitignore, the LICENSE, the README and a single addons/ directory, so the entire plugin is that one folder and everything else is repository furniture. There is no build step, no package manifest and no test suite in the listing.

The upgrade instructions are worth reading, because they are the most common way to break an editor plugin. You close all your scenes, especially those in which there is some SimpleGrassTextured, then disable the plugin in Project Settings, then delete the addons/simplegrasstextured folder from your project, then install the new version, then enable it again and reload Godot. The close-your-scenes step exists because a plugin holding references to open scenes will not survive being deleted underneath the editor.

Drawing on the terrain, and the StaticBody3D requirement

The usage model is unusually direct for a 3D plugin. You add a SimpleGrassTextured node to your terrain scene, and then you select that node on your scene and draw on the terrain.

There is one hard prerequisite, stated in the documentation: your terrain scene must have a StaticBody3D in order to draw grass on top of the terrain. That is not a stylistic note, it is a functional dependency, because the grass is placed against the collision surface of the terrain rather than against its visual mesh. A terrain mesh without a matching static body gives you no surface to draw onto.

The customisation surface is two inspector fields on the same node. You can load a custom mesh on the mesh property, and on the Texture Albedo you can load your own texture, and in the surface settings section of that inspector you can adjust how it looks. So the grass blade geometry and its texture are both replaceable without touching code.

The licence situation has two layers and they are worth separating. The plugin itself is MIT. The one bundled asset, the texture grassbushcc008.png, is CC0 licensed and credited to FabinhoSC from OpenGameArt, at the page for stylised grass and bush textures. That split is the right way to do it, because the asset and the code have different origins and different terms, and a project that ships the plugin can tell its users which is which.

Interactive mode, and the collision layer that carries it

The interactive mode is what turns the plugin from a decoration into a terrain system, and it works through a dedicated render layer rather than through physics in the usual sense.

The setup has five steps. In the _ready function of your game scene you enable the interactive mode by calling the function SimpleGrass.set_interactive(true). Next you enable the character to be detected by the SimpleGrassTextured collision system, and for this it is recommended to add a MeshInstance3D to the character, for example a sphere, at the height of the ground, and you can adjust the size of the sphere so that the collision is detected more accurately. In the render layers of that MeshInstance3D, only layer 17 should be enabled. Then in the active camera you disable display layer 17, so that objects that are only interactable with SimpleGrassTextured are not visible. Finally, in your character's _process or _physics_process function you update SimpleGrassTextured by calling SimpleGrass.set_player_position(global_position).

The layer 17 trick is the interesting part and it is the reason the camera step exists. The collision proxy does not need to be seen, but it does need to be rendered for the grass system to detect it, so it is put on a render layer that the camera culls and the plugin reads. The same procedure can be done for each character or object that must interact with SimpleGrassTextured, so a scene with several interactive characters needs a proxy on each.

The position update in _process or _physics_process is where the cost sits, and it is why the optimisation section that follows matters. Every frame, the plugin is told where the character is and works out what to do with the grass around it. The sphere size affects detection accuracy, so a small sphere gives precise reactions on small characters and a large one makes a big character's passage visible over a wider area.

Three optimisations, one of which you have to remember to redo

The optimisation section is short and the advice is concrete.

Shadows can be disabled. For short grasses where shadows are not necessary, they can be turned off via the SimpleGrassTextured menu in the top bar. Grass shadow casting is a classic performance sink in a 3D scene, because each blade is a separate piece of geometry being rendered twice, and for dense grass on a low-spec machine it is often the first thing to go.

The height map can be baked. If you have enabled the interactive mode, you can speed up the loading time by baking the heightmap, mainly if there are a large number of grasses, and you do it from the same top bar menu. The instruction that comes with it is the important part: be sure to do this if you make any changes to the grasses.

That instruction is a maintenance obligation rather than a one-off step. The baked height map is a snapshot of the grass layout, so if you add, remove or move grass afterwards, the bake is stale and you have to do it again. A project where grass is placed by a designer who then tweaks it repeatedly will find itself re-baking often, which is the sort of friction that eats a tool's usefulness.

The LOD optimisation is about positioning rather than a setting. Use the auto center position tool in the SimpleGrassTextured menu to adjust the node position, so that Godot's LOD system works correctly. If your custom mesh does not display correctly, try adjusting LOD Bias. The reason this matters is specific to grass: an enormous number of small objects spread over a large area is exactly the case where Godot's level of detail system, which culls distant objects, either does nothing useful or removes the wrong things if the node's bounding volume is not centred on the visible grass.

Editorial conclusion

SimpleGrassTextured suits a Godot 4 developer who wants grass on a terrain without writing a shader, and the editor workflow of drawing directly on the terrain is the part that makes it approachable. It does not suit you if you need a custom shader pipeline or procedural wind, because the plugin is a fixed implementation with a fixed mesh and material rather than a system you extend. Before you ship a scene built with it, read the optimisation section, since the baking step has to be redone whenever the grass changes, and note that the one bundled texture is CC0 licensed from OpenGameArt while the plugin itself is MIT.

Frequently asked questions

Official sources

1. IcterusGames/SimpleGrassTextured on GitHub
2. Issues
3. License: MIT
4. README
5. Releases