There’s lots of models that have replicated data, buildings + building contents, eg. doors + radiators/furniture tend to have lots of flat surfaces that are parallel to each other, which will lead to lots of common normals + shared triangle vertices. You could have 6 normals for up/down/left/right/front/back or hundreds/thousands of replicated normals if each vertex has it’s own normal.

If you have to form unique vertices, it also means you have to duplicate the position data, so position data will take up more space.

You might have a door that could be modelled with a grid (where each vertex is surrounded by 6 triangles) which could have:

120 position (120*3*4)

14 normals (14*3*4)

Assuming you were using GL_TRIANGLES, then you would have 720 triangle-vertices in this grid.

position indices: 720 * 1

normals indices: 720 * 1

total = 3048 bytes

But when you force each vertex to be unique, every vertex will now need to replicate the positions as well as the normals, so you would have:

~240 positions (each position is used by 6 triangles, approximately 3 of these share same normal too so can be merged into one vertex) (240*3*4)

~240 normals (240 * 3 * 4)

720 * 1-byte indices (720 * 1), but if the model were slightly larger, would need to use 2-byte indices since we can no longer identify every piece of data with a single byte

total = 6480 bytes

That’s over twice the size. Even if the indices in the separate indices case used 2 bytes, that would still only be 4488 bytes vs 7200 bytes, the model without separate indices is still much larger, because of the extra space required in duplicating each position as well as each normal. With the larger number of vertices, you will also need to start using larger index types sooner.

If separate indices were introduced to OpenGL, there could be caching of values per-index, so if it’s just accessed the normal with index 0, then it could store the same value + re-use it if the next vertex uses the same value.

It could even store the calculated values that only depend on this attribute + uniforms, which might save on some matrix-multiplications for example if you had

```
n = normalize(NormalMatrix * normal);
```

then this computed value could be cached. This would mean you might want to group all triangles with the same normal next to each other in the mesh.

Of course it will only be useful for certain types of models, but that’s why there’s different drawing routines etc.