void ReadSparseBinaryData()

in GLTFSDK/Inc/GLTFSDK/GLTFResourceReader.h [353:402]
42 lines of code
8 McCabe index (conditional complexity)

            void ReadSparseBinaryData(const Document& gltfDocument, std::vector<T>& baseData, const Accessor& accessor) const
            {
                const auto typeCount = Accessor::GetTypeCount(accessor.type);
                const auto elementSize = sizeof(T) * typeCount;

                const size_t count = accessor.sparse.count;

                const BufferView& indicesBufferView = gltfDocument.bufferViews.Get(accessor.sparse.indicesBufferViewId);
                const Buffer& indicesBuffer = gltfDocument.buffers.Get(indicesBufferView.bufferId);
                const size_t indicesOffset = accessor.sparse.indicesByteOffset + indicesBufferView.byteOffset;

                const BufferView& valuesBufferView = gltfDocument.bufferViews.Get(accessor.sparse.valuesBufferViewId);
                const Buffer& valuesBuffer = gltfDocument.buffers.Get(valuesBufferView.bufferId);
                const size_t valuesOffset = accessor.sparse.valuesByteOffset + valuesBufferView.byteOffset;

                std::vector<I> indices;

                if (!indicesBufferView.byteStride || indicesBufferView.byteStride.Get() == sizeof(I))
                {
                    indices = ReadBinaryData<I>(indicesBuffer, indicesOffset, count);
                }
                else
                {
                    indices = ReadBinaryDataInterleaved<I>(indicesBuffer, indicesOffset, count, 1U, indicesBufferView.byteStride.Get());
                }

                std::vector<T> values;

                if (!valuesBufferView.byteStride || valuesBufferView.byteStride.Get() == elementSize)
                {
                    values = ReadBinaryData<T>(valuesBuffer, valuesOffset, count * typeCount);
                }
                else
                {
                    values = ReadBinaryDataInterleaved<T>(valuesBuffer, valuesOffset, count, typeCount, valuesBufferView.byteStride.Get());
                }

                for (size_t i = 0; i < indices.size(); i++)
                {
                    assert(baseData.size() == accessor.count * typeCount);
                    static_assert(sizeof(I) <= sizeof(size_t), "sizeof(I) < sizeof(size_t)");
                    if (0 <= indices[i] && static_cast<size_t>(indices[i]) < accessor.count)
                    {
                        for (size_t j = 0; j < typeCount; j++)
                        {
                            baseData[indices[i] * typeCount + j] = values[i * typeCount + j];
                        }
                    }
                }
            }