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