One material per model or multiple reusable materials per model?

I was wondering what would be the best approach for applying materials / textures to models:

  1. A single material per model, for example creating the model in Blender, texturing there and baking the textures, then import the textures into Godot.
  2. Create multiple materials that will be reused across multiple models, for example a wood texture can be used in different box models.

For option 2, it’s possible to create a model that allows the use of multiple materials and this is recognized in Godot. With this in mind one could create multiple materials that can be reused in different models, for example, one wood, steel and aluminum materials. Then we could have two different boxes, that use the same wood material, but different material for the screws (steel, aluminum).

For option 2, materials could be created procedurally in shaders, this would allow changing settings, for example, we could make the steel material appear rusty.
For details, like text and other things, it could de added as another material with a texture.

I believe option 1 is the standard, it allows to create a very custom appearance per model, with scratches, scuffs, etc.

Maybe option 2 could reduce memory consumption since materials would be reused.
I don’t know about the performance difference between the two options.

I would think that option 1 could be less efficient and more laggy, but option 2 could let you be more efficient, and less laggy.

There is no good answer or solution for this. It’s a tradeoff and it entirely depends on your game.

This, there are quite a few pipelines for setting up assets, and like what is said above, depending on your needs, one will be better than the others, but also remember that more than one pipeline can exist depending on the type of asset, its use, and the tech, timelines and talent you have available to make these assets.

The below is long and a set of opinions and ideas based on my current knowledge, some of it of how other engines work, so buyer beware and hopefully other amend or correct me if any of it is wrong.

In this case, there are generally four things that you’ll want to consider when talking how things are setup

  • Texture Memory
  • Model/Surface Draw Call Numbers
  • Shader Complexity
  • Asset Creation Complexity

So in your case, here is how I’d rank those two ideas with the above in mind:

Single material per model with uniquely created textures (maybe some parts that re-use parts of the material):

  • Texture Memory - Higher - In general it’s higher as depending on your scene setup, you might have a lot more unique textures loaded at any one time in game, but these things ‘can’ be mitigated by object control in your scenes and tech like texture streaming and virtual textures.
  • Model/Surface Draw Call Numbers - Lower - This is where this shines, the number of materials per object is lower, especially if it’s just one per, when you want a ton of objects drawn on the screen at the same time, this helps a lot.
  • Shader Complexity - Lower - Another area this shines, without all of the layers and texture samplers and reads that material layer systems need, each surface will be a lot cheaper to draw.
  • Asset Creation Complexity - Depends - What kind of talent you have to do these assets and implementations will determine if this is better or worse. If you have solid modelers and texture artists available, this is much better as there is really no complex setup in the engine to set these up.

Create multiple materials that will be reused across multiple models:

  • Texture Memory - Lower - If you are reusing a lot of texture assets, this can be a lot lower, whether you are using single tiled textures/materials or trim sheet setups.
  • Model/Surface Draw Call Numbers - Higher - This can get out of hand pretty quick depending on the surface complexity for your models, as if you have an item that needs wood, metal and cloth, and those are separate materials, you have increased its draw cost by 2 at least.
  • Shader Complexity - Lower - If each material drawn on each surface is only simple shader setup and just the typical texture needs (diffuse, normal, orm, etc), this is inexpensive.
  • Asset Creation Complexity - Higher - While the textures might be easier to make on the asset side, the models will be more complex as the artist creating the asset outside of the engine will need to make sure to setup the materials on the mesh correctly to match what is needed in engine. Then the implementation in engine will be a good deal more complex as to make sure the models are using the proper materials, in the proper slots on the mesh and objects, and control over new assets and changed as without oversight a simple change might cause a lot of issues due to dependencies.

More complex shaders to enable more procedural materials:

  • Texture Memory - Lower - Like with above, layered materials and other ways of doing this type of technique, usually need smaller textures due to tiling and combining and reusing existing ones to create new surface looks.
  • Model/Surface Draw Call Numbers - Lower - If you have a few master shaders where you can make a lot of unique materials out of them with all of the available parameters and sliders, this can be much lower.
  • Shader Complexity - Higher - This can get out of control pretty quick with a lot of texture reads and complex shader code on each pixel drawn, including a lot of other potential issues with things like compatibility and what complex part of the shader can be a problem with the engine you are using, its version, etc.
  • Asset Creation Complexity - Higher - While this might be ok on the model and texture creation side, the setup in engine for the shaders, the proper parameters and textures used to get the looks wanted can be costly on the tech art side creating the shaders and pipeline, but also on the art direction side to keep consistency, etc.

There are more options and info here for sure, but I wanted to lay out some things to consider.

1 Like