In the most general sense, no. OpenGL and Direct3D allow only one pointer to the top; an index is retrieved from each vertex data stream. Therefore, each unique combination of components must have its own separate index.
Therefore, if you have a cube where each face has its own normal, you will need to copy the position and normal data many times. You will need 24 positions and 24 normals, although the cube will have only 8 unique positions and 6 unique normals.
It’s best to simply accept that your data will be larger. Many model formats will use multiple indexes; you will need to correct this vertex information before you can do with it. Many grid loading tools, such as the Open Asset Importer, will perform this setup for you.
GL 3.x and D3D10
For D3D10 / OpenGL 3.x hardware, you can avoid a patch and use multiple indexed attributes at once. However, keep in mind that this is likely to reduce rendering performance.
The following discussion will use OpenGL terminology, but Direct3D v10 and above have equivalent functionality.
The idea is to manually access the various vertex attributes from the vertex shader. Instead of sending vertex attributes directly, the passed attributes are actually indexes for that particular vertex. The vertex shader then uses indexes to access the actual attribute through one or more buffer textures .
Attributes can be stored in several buffer textures or all inside one. If the latter is used, the shader will need an offset to be added to each index in order to find the corresponding index of the beginning of the attribute in the buffer.
Regular vertex attributes can be compressed in many ways. Buffer textures have fewer compression tools, which allows you to use only a relatively limited number of vertex formats (through the image formats they support).
Note that any of these methods may reduce overall vertex processing performance. Therefore, it should be used only in the most limited circumstances, after all other compression or optimization options have been exhausted.
OpenGL ES 3.0 also provides buffer textures. Higher versions of OpenGL allow faster reading of buffer objects via SSBOs, rather than buffer textures, which can have higher performance characteristics.