- Qt 6.5
- Qt Quick 3D
- Qt Quick 3D Examples and Tutorials
- Qt Quick 3D - Custom Instanced Rendering
- Qt Quick 3D | Commercial or GPLv3

# Qt Quick 3D - Custom Instanced Rendering

     // Copyright (C) 2020 The Qt Company Ltd.
     // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

     #include "cppinstancetable.h"
     #include <math.h>
     #include <QMatrix4x4>
     #include <QRandomGenerator>
     #include <QColor>

     // Quick-and-dirty smoothed out noise generation. Probably not suitable for general use.
     static QVector<float> generateNoiseTable(int dimension, int randomSeed)
     {
         const int tableSize = dimension * dimension;
         QVector<float> table(tableSize);
         QRandomGenerator rgen(randomSeed);

         for (float &f: table)
             f = rgen.bounded(1.0) * rgen.bounded(1.0);

         // We select some initial points that will not be modified. This is the distance between them: (power of two)
         constexpr int delta = 16;

         // Then we average out those points to the points half way between them,
         // and continue with the points half way between those, and so on.
         // Pattern:
         // STS
         // TTT
         // STS
         // where S = source and T = target
         auto smooth = [dimension, &table](int x, int y, int d) {
             auto lookup = [&table,dimension](int x, int y) -> float {
                 return table[x + y*dimension];
             };
             auto assign = [&table,dimension,d](int x, int y, float v) {
                 if (x < dimension && y < dimension) {
                     float e = d*1.0/dimension;
                     float &z = table[x + y*dimension];
                     z = (e*z + v)/(e+1);
                 }
             };

             int x1 = x + d/2;
             int y1 = y + d/2;
             int x2 = qMin(dimension-1, x + d);
             int y2 = qMin(dimension-1, y + d);
             float z1 = lookup(x,y);
             float z2 = lookup(x2, y);
             float z3 = lookup(x, y2);
             float z4 = lookup(x2, y2);
             assign(x1, y, (z1+z2)/2);
             assign(x, y1, (z1+z3)/2);
             assign(x1, y1, (z1+z2+z3+z4)/4);
             assign(x1, y2, (z3+z4)/2);
             assign(x2, y1, (z2+z4)/2);
         };

         int d = delta;
         while (d > 1) {
             for (int ix = 0; ix < dimension; ix += d) {
                 for (int iy = 0; iy < dimension; iy += d) {
                     smooth(ix, iy, d);
                 }
             }
             d = d/2;
         }

         //low-pass filter
         for (int i = dimension + 1; i < tableSize; ++i)
             table[i] = (table[i] + table[i-1] + table[i-dimension])/3;

         //normalize
         float min = 1.0;
         float max = 0.0;
         for (auto z : table) {
             min = qMin(z, min);
             max = qMax(z, max);
         }
         for (auto &z : table)
             z = (z - min) / (max - min);

         return table;
     }

     CppInstanceTable::CppInstanceTable(QQuick3DObject *parent) : QQuick3DInstancing(parent)
     {
         m_randomSeed = QRandomGenerator::global()->generate();
     }

     CppInstanceTable::~CppInstanceTable()
     {
     }

     int CppInstanceTable::gridSize() const
     {
         return m_gridSize;
     }

     float CppInstanceTable::gridSpacing() const
     {
         return m_gridSpacing;
     }

     int CppInstanceTable::randomSeed() const
     {
         return m_randomSeed;
     }

     void CppInstanceTable::setGridSize(int gridSize)
     {
         if (m_gridSize == gridSize)
             return;

         m_gridSize = gridSize;
         emit gridSizeChanged();
         markDirty();
         m_dirty = true;
     }

     void CppInstanceTable::setGridSpacing(float gridSpacing)
     {
         if (qFuzzyCompare(m_gridSpacing, gridSpacing))
             return;

         m_gridSpacing = gridSpacing;
         emit gridSpacingChanged();
         markDirty();
         m_dirty = true;
     }

     void CppInstanceTable::setRandomSeed(int randomSeed)
     {
         if (m_randomSeed == randomSeed)
             return;

         m_randomSeed = randomSeed;
         emit randomSeedChanged();
         markDirty();
         m_dirty = true;
     }

     class BlockTable
     {
     public:
         BlockTable(int dimension, int randomSeed) : gridSize(dimension), seaLevel(gridSize / 8)
         {
             noiseTable = generateNoiseTable(gridSize, randomSeed);
             lowestBlock.resize(gridSize * gridSize);

             for (int i = 0; i < gridSize; ++i) {
                 for (int j = 0; j < gridSize; ++j) {
                     // optimization: skip blocks that are obscured by neighbours
                     int lowestVisible;
                     if (i == 0 || j == 0 || i == gridSize - 1 || j == gridSize - 1) {
                         lowestVisible = 0;
                     } else {
                         lowestVisible = terrainHeight(i, j);
                         lowestVisible = qMin(lowestVisible, terrainHeight(i - 1, j));
                         lowestVisible = qMin(lowestVisible, terrainHeight(i, j - 1));
                         lowestVisible = qMin(lowestVisible, terrainHeight(i + 1, j));
                         lowestVisible = qMin(lowestVisible, terrainHeight(i, j + 1));
                         lowestVisible = qMax(lowestVisible, seaLevel);
                     }
                     lowestBlock[idx(i, j)] = lowestVisible;
                 }
             }
         }

         QColor getBlockColor(int i, int j, int k) const
         {
             const int maxHeight = gridSize / 2;
             int snowLine = maxHeight * 4 / 5 - QRandomGenerator::global()->bounded(maxHeight / 5);
             int treeLine = maxHeight * 3 / 5 - QRandomGenerator::global()->bounded(maxHeight / 5);
             if (k > terrainHeight(i, j)) {
                 return Qt::blue;
             } else if (k > snowLine) {
                 return Qt::white;
             } else if (k > treeLine) {
                 return Qt::darkGray;
             } else {
                 return QColor::fromHsvF(k * 0.7f / maxHeight, 0.7f, 0.5f, 1.0f);
             }
         }
         bool isWaterSurface(int i, int j, int k) const { return k == seaLevel && k > terrainHeight(i, j); }
         int lowestVisible(int i, int j) { return lowestBlock[idx(i, j)]; }
         int highestBlock(int i, int j) { return qMax(seaLevel, terrainHeight(i, j)); }

     private:
         int idx(int i, int j) const { return i + j * gridSize; }
         int terrainHeight(int i, int j) const
         {
             const int maxHeight = gridSize / 2;
             return maxHeight * noiseTable[idx(i, j)];
         }

         QVector<float> noiseTable;
         QVector<int> lowestBlock;
         int gridSize;
         int seaLevel;
     };

     QByteArray CppInstanceTable::getInstanceBuffer(int *instanceCount)
     {
         if (m_dirty) {
             BlockTable blocks(m_gridSize, m_randomSeed);
             m_instanceData.resize(0);

             auto idxToPos = [this](int i) -> float { return m_gridSpacing * (i - m_gridSize / 2); };

             int instanceNumber = 0;
             for (int i = 0; i < m_gridSize; ++i) {
                 float xPos = idxToPos(i);
                 for (int j = 0; j < m_gridSize; ++j) {
                     float zPos = idxToPos(j);
                     int lowest = blocks.lowestVisible(i, j);
                     int highest = blocks.highestBlock(i, j);
                     for (int k = lowest; k <= highest; ++k) {
                         float yPos = idxToPos(k);
                         QColor color = blocks.getBlockColor(i, j, k);
                         float waterAnimation = blocks.isWaterSurface(i, j, k) ? 1.0 : 0.0;
                         auto entry = calculateTableEntry({ xPos, yPos, zPos }, { 1.0, 1.0, 1.0 }, {}, color, { waterAnimation, 0, 0, 0 });
                         m_instanceData.append(reinterpret_cast<const char *>(&entry), sizeof(entry));
                         instanceNumber++;
                     }
                 }
             }
             m_instanceCount = instanceNumber;
             m_dirty = false;
         }
         if (instanceCount)
             *instanceCount = m_instanceCount;

         return m_instanceData;
     }