Warning, file /frameworks/kquickcharts/src/scenegraph/SDFShader.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
  * This file is part of KQuickCharts
  * SPDX-FileCopyrightText: 2019 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  */
 
 #ifndef SDF_SHADER_H
 #define SDF_SHADER_H
 
 #include <QSGMaterialShader>
 
 struct UniformDataStream {
     inline UniformDataStream(QSGMaterialShader::RenderState &state) noexcept
         : bytes(state.uniformData()->data())
     {
     }
 
     ~UniformDataStream()
     {
     }
 
     template<typename Data>
     friend inline UniformDataStream &operator<<(UniformDataStream &stream, const Data &data)
     {
         constexpr uint dataSize = sizeof(Data);
         stream.align(dataSize);
         memcpy(stream.bytes, &data, dataSize);
         stream.bytes += dataSize;
         stream.offset += dataSize;
         return stream;
     }
 
     template<typename Data>
     inline void skip(const Data &data = {})
     {
         constexpr uint dataSize = sizeof(Data);
 
         align(dataSize);
         Q_UNUSED(data);
         bytes += dataSize;
         offset += dataSize;
     }
 
     inline void skipComponents(uint count)
     {
         const uint skipCount = count * 4;
         align(4);
         bytes += skipCount;
         offset += skipCount;
     }
 
     friend inline UniformDataStream &operator<<(UniformDataStream &stream, const QMatrix4x4 &m)
     {
         constexpr uint Matrix4x4Size = 4 * 4 * 4;
 
         stream.align(Matrix4x4Size);
         memcpy(stream.bytes, m.constData(), Matrix4x4Size);
         stream.bytes += Matrix4x4Size;
         stream.offset += Matrix4x4Size;
         return stream;
     }
 
     friend inline UniformDataStream &operator<<(UniformDataStream &stream, const QColor &color)
     {
         constexpr uint ColorSize = 4 * 4;
 
         stream.align(ColorSize);
         std::array<float, 4> colorArray;
         color.getRgbF(&colorArray[0], &colorArray[1], &colorArray[2], &colorArray[3]);
         memcpy(stream.bytes, colorArray.data(), ColorSize);
         stream.bytes += ColorSize;
         stream.offset += ColorSize;
         return stream;
     }
 
     template<typename T>
     friend inline UniformDataStream &operator<<(UniformDataStream &stream, const QList<T> &v)
     {
         for (const auto &item : v) {
             stream << item;
             // Using std140, array elements are padded to a size of 16 bytes per element.
             stream.align(16);
         }
         return stream;
     }
 
     char *bytes;
     size_t padding = 16;
     size_t offset = 0;
 
 private:
     // Encode alignment rules for std140.
     // Minimum alignment is 4 bytes.
     // Vec2 alignment is 8 bytes.
     // Vec3 and Vec4 alignment is 16 bytes.
     inline void align(uint size)
     {
         if (size <= 4) {
             const auto padding = offset % 4 > 0 ? 4 - offset % 4 : 0;
             offset += padding;
             bytes += padding;
         } else if (size <= 8) {
             auto padding = offset % 8 > 0 ? 8 - offset % 8 : 0;
             offset += padding;
             bytes += padding;
         } else {
             auto padding = offset % 16 > 0 ? 16 - offset % 16 : 0;
             offset += padding;
             bytes += padding;
         }
     }
 };
 
 class SDFShader : public QSGMaterialShader
 {
 public:
     SDFShader();
     virtual ~SDFShader();
 
     void setShaders(const QString &vertex, const QString &fragment);
 };
 
 #endif // SDF_SHADER_H