path: root/examples/quick3d/custominstancing/cppinstancetable.cpp

// 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;
};

//! [getInstanceBuffer]
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;
}
//! [getInstanceBuffer]