qssggltfaccessorreader.cpp

Go to the documentation of this file.

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser
 
#include "qssggltfaccessorreader_p.h"
 
#include <cstring>
 
QT_BEGIN_NAMESPACE
 
using namespace QSSGGltf;
 
/*!
    \namespace QSSGGltfAccessorReader
    \internal
 
    Typed access to glTF accessor data. All functions compose the buffer view
    byte stride (interleaved data), the accessor byte offset, and sparse
    substitution, and return tightly packed copies. An accessor without a
    buffer view yields zeros, as the specification requires.
*/
namespace QSSGGltfAccessorReader {
 
namespace {
 
// Pointer to the first element and the stride between elements for data in
// a buffer view; null when the accessor has no buffer view.
struct DataView {
    const char *data = nullptr;
    qsizetype stride = 0;
};
 
DataView viewForAccessor(const QSSGGltfDocument &document, const Accessor &accessor)
{
    if (accessor.bufferView < 0)
        return {};
    const BufferView &view = document.bufferViews.at(accessor.bufferView);
    const Buffer &buffer = document.buffers.at(view.buffer);
    DataView result;
    result.stride = view.byteStride > 0 ? view.byteStride : accessor.elementByteSize();
    result.data = buffer.data.constData() + view.byteOffset + accessor.byteOffset;
    return result;
}
 
quint32 readIndexValue(const char *data, Accessor::ComponentType componentType)
{
    switch (componentType) {
    case Accessor::ComponentType::UnsignedByte:
        return *reinterpret_cast<const quint8 *>(data);
    case Accessor::ComponentType::UnsignedShort: {
        quint16 value;
        std::memcpy(&value, data, sizeof(value));
        return value;
    }
    case Accessor::ComponentType::UnsignedInt: {
        quint32 value;
        std::memcpy(&value, data, sizeof(value));
        return value;
    }
    default:
        break;
    }
    return 0;
}
 
void applySparse(const QSSGGltfDocument &document, const Accessor &accessor, QByteArray &packed)
{
    const Accessor::Sparse &sparse = *accessor.sparse;
    const qsizetype elementSize = accessor.elementByteSize();
 
    const BufferView &indicesView = document.bufferViews.at(sparse.indicesBufferView);
    const Buffer &indicesBuffer = document.buffers.at(indicesView.buffer);
    const char *indices = indicesBuffer.data.constData() + indicesView.byteOffset + sparse.indicesByteOffset;
    const qsizetype indexSize = Accessor::componentByteSize(sparse.indicesComponentType);
 
    const BufferView &valuesView = document.bufferViews.at(sparse.valuesBufferView);
    const Buffer &valuesBuffer = document.buffers.at(valuesView.buffer);
    const char *values = valuesBuffer.data.constData() + valuesView.byteOffset + sparse.valuesByteOffset;
 
    for (qint64 i = 0; i < sparse.count; ++i) {
        const quint32 targetElement = readIndexValue(indices + i * indexSize, sparse.indicesComponentType);
        if (qint64(targetElement) >= accessor.count)
            continue; // structurally invalid substitution index; skip
        std::memcpy(packed.data() + qsizetype(targetElement) * elementSize, values + i * elementSize, elementSize);
    }
}
 
float componentToFloat(const char *data, Accessor::ComponentType componentType, bool normalized)
{
    switch (componentType) {
    case Accessor::ComponentType::Byte: {
        const qint8 value = *reinterpret_cast<const qint8 *>(data);
        return normalized ? std::max(value / 127.0f, -1.0f) : float(value);
    }
    case Accessor::ComponentType::UnsignedByte: {
        const quint8 value = *reinterpret_cast<const quint8 *>(data);
        return normalized ? value / 255.0f : float(value);
    }
    case Accessor::ComponentType::Short: {
        qint16 value;
        std::memcpy(&value, data, sizeof(value));
        return normalized ? std::max(value / 32767.0f, -1.0f) : float(value);
    }
    case Accessor::ComponentType::UnsignedShort: {
        quint16 value;
        std::memcpy(&value, data, sizeof(value));
        return normalized ? value / 65535.0f : float(value);
    }
    case Accessor::ComponentType::UnsignedInt: {
        quint32 value;
        std::memcpy(&value, data, sizeof(value));
        return float(value);
    }
    case Accessor::ComponentType::Float: {
        float value;
        std::memcpy(&value, data, sizeof(value));
        return value;
    }
    }
    return 0.0f;
}
 
} // namespace
 
/*!
    \internal
 
    Returns the element data of accessor \a accessorIndex in \a document,
    packed to accessor.elementByteSize() per element.
*/
QByteArray readPacked(const QSSGGltfDocument &document, int accessorIndex)
{
    if (accessorIndex < 0 || accessorIndex >= document.accessors.size())
        return {};
    const Accessor &accessor = document.accessors.at(accessorIndex);
    const qsizetype elementSize = accessor.elementByteSize();
 
    QByteArray packed(accessor.count * elementSize, '\0');
    const DataView view = viewForAccessor(document, accessor);
    if (view.data) {
        if (view.stride == elementSize) {
            std::memcpy(packed.data(), view.data, packed.size());
        } else {
            // Bound the loop by what was actually allocated rather than by
            // accessor.count, so that this stays inside the destination even
            // if the count and the allocation ever disagree
            const qint64 count = packed.size() / elementSize;
            for (qint64 i = 0; i < count; ++i)
                std::memcpy(packed.data() + i * elementSize, view.data + i * view.stride, elementSize);
        }
    }
 
    if (accessor.sparse.has_value())
        applySparse(document, accessor, packed);
 
    return packed;
}
 
/*!
    \internal
 
    Returns the element data of accessor \a accessorIndex in \a document,
    converted to floats, accessor.componentCount() per element. Normalized
    integer component types are dequantized as the specification describes
    (c/255, max(c/127, -1), ...), which also covers accessors quantized per
    KHR_mesh_quantization; non-normalized integers are cast.
*/
QList<float> readAsFloats(const QSSGGltfDocument &document, int accessorIndex)
{
    if (accessorIndex < 0 || accessorIndex >= document.accessors.size())
        return {};
    const Accessor &accessor = document.accessors.at(accessorIndex);
    const QByteArray packed = readPacked(document, accessorIndex);
    const int components = Accessor::componentCount(accessor.type);
    const int componentSize = Accessor::componentByteSize(accessor.componentType);
 
    QList<float> result(accessor.count * components);
    const char *element = packed.constData();
    for (qsizetype i = 0; i < result.size(); ++i)
        result[i] = componentToFloat(element + i * componentSize, accessor.componentType, accessor.normalized);
    return result;
}
 
/*!
    \internal
 
    Returns the scalar index data of accessor \a accessorIndex in \a document,
    widened to 32-bit unsigned integers.
*/
QList<quint32> readIndices(const QSSGGltfDocument &document, int accessorIndex)
{
    if (accessorIndex < 0 || accessorIndex >= document.accessors.size())
        return {};
    const Accessor &accessor = document.accessors.at(accessorIndex);
    const QByteArray packed = readPacked(document, accessorIndex);
    const qsizetype componentSize = Accessor::componentByteSize(accessor.componentType);
 
    QList<quint32> result(accessor.count);
    for (qint64 i = 0; i < accessor.count; ++i)
        result[i] = readIndexValue(packed.constData() + i * componentSize, accessor.componentType);
    return result;
}
 
} // namespace QSSGGltfAccessorReader
 
QT_END_NAMESPACE