The Change
As described in T91186, this patch moves mesh vertex normals into a
separate custom data layer, like how face normals are currently stored.
The normal array values are now stored as floats, in a contiguous array.
The patch also changes code to use on-demand calculation for vertex and
face normals. Vertex normals are retrieved with an "ensure" function,
and cached in vertex custom data storage. Face normals are handled in
the same way. The main interface is described in BKE_mesh.c.
Since the logical state of a mesh is now "has normals when necessary",
normals can be retrieved from a const mesh, protected by a mutex.
The goal is to use on-demand calculation for derived data, but leave
room for eager calculation for performance purposes (i.e. modifier
evaluation is threaded, but viewport data generation is not).
Benefits
This moves us closer to a SoA approach rather than the current AoS
paradigm. This makes accessing each value faster, since accessing
a contiguous float3 array can be much more efficient than abstracting
the storage. It also means less memory needs to be loaded to read
mesh positions. And at the cost of more memory usage, normals now
don't have to be converted between float and short all the time.
The best example of this change is in node_geo_input_normal.cc.
In the future, the remaining items can be removed from MVert, and
we will just be left with float3, which has similar benefits (T93602).
This approach makes it much simpler to use lazy calculation of normals,
meaning we can easily defer calculation until it's actually needed.
This is especially important now that we have more opportunities for
temporary meshes in geometry nodes.
Performance
In addition to the theoretical future performance improvements by
making MVert == float3, I've done some basic performance testing
on this patch directly. The performance data I've taken is fairly rough,
but it should be enough to give us an idea about where things
generally stand.
| Test | Before | After | Notes |
|---|---|---|---|
| Mesh Line Primitive | 36 ms | 31 ms (1.16x) | I'll let this stand in for many areas to show that simply filling in mesh vertex positions is faster, since less memory needs to be accessed. I expect many similar speedups. |
| Spring Splash Screen | 1.03-1.06 fps | 1.06-1.11 fps | It looks like a slight improvement here. Would need better measurement to have a strong conclusion though. |
| Sprite Fright Snail Smoosh | 3.30-3.40 fps | 3.42-3.50 fps | Due to the non-scientific testing I won't draw a strong conclusion, but this looks like a noticeable improvement. |
| Set Position with Scaled Normal | 53 ms | 39 ms (1.36x) | This test shows that using normals in geometry nodes is noticeably faster |
| Normal Calculation 1.6m Vert Cube | 25 ms | 21 ms (1.19x) | Calculation of normals itself is noticeably master, possibly because of the lack of float -> short conversion |
| File Size of 1.6m Vert Cube | 214.7 MB | 208.4 MB (1.03x) | Files with large meshes can have savings since we no longer save normals unnecessarily |
As for memory usage, it may be slightly larger in some cases.
But I didn't notice any difference in the production files I tested.
Tests
Some tests are failing now, for two reasons. First is that normals
are now dirty after the subdivision surface modifier. Even in current
master, the modifier creates different normals than the result
of the Mesh normal calculation. You can observe this by adding a
BKE_mesh_calc_normals call after the modifier in master.
The other test differences are small changes in the result from things
like the displace modifier, where storing normals in floats instead of
shorts gives a slightly different result.
Test results can be updated when the patch is committed.
Future improvements
- Remove ModifierTypeInfo::dependsOnNormals. Code in each modifier already retrieves normals if they are needed anyway.
- Copy normals as part of a better CoW system for attributes.
- Make more areas use lazy instead of eager normal calculation.
- Remove BKE_mesh_normals_tag_dirty in more places since that is the default state of a new mesh.
