Shader Diffing

The problem

• Scene is updated immutably and rendered as a pure function
• Every primitive requires knowing which shader to use
• Every shader requires some runtime variables be set depending on scene contents (not only primitive contents)
• Generating and uploading a new shader is expensive

The solution

1. A plain object called shaderConfig is derived for each scene + primitive combo.

2. This object is hashed, resulting in a shaderHash (just a plain string). This hash is used to lookup in a global map for a compiled shader.

3. If the shader is not found for that hash, it is compiled and stored. Compiling a shader requires passing the shaderConfig object (and nothing else)

Performance concerns

All of this happens every tick (though of course cache misses are typically only on the first tick). Therefore, creating shaderConfig and hashing it must be very fast (and they are - setting shaderConfig is mostly unrolled settings of flags, and the hash is a hand-tuned approach that was tested against several other approaches).

This is one of the reasons why extensions are hardcoded rather than an open and flexible api (though conceptually they could be dynamically loaded and just append the hash string).

At this point from some minimal tests - it seems to support a few thousand gltf objects no problem. At that point the bottleneck is almost definitely somewhere else in the system rather than diffing/hashing. Since it's all pure data, this work could be offloaded to a separate thread as well.