proceduralskytexturedata.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
/*
  Based on "sky.cpp" from the Godot engine v3
  Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.
  Copyright (c) 2014-2022 Godot Engine contributors.
*/
 
#include "proceduralskytexturedata_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrendertexturedata_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderimage_p.h>
 
QT_BEGIN_NAMESPACE
 
ProceduralSkyTextureData::ProceduralSkyTextureData()
{
    scheduleTextureUpdate();
}
 
ProceduralSkyTextureData::~ProceduralSkyTextureData()
{
}
 
QColor ProceduralSkyTextureData::skyTopColor() const
{
    return m_skyTopColor;
}
 
QColor ProceduralSkyTextureData::skyHorizonColor() const
{
    return m_skyHorizonColor;
}
 
float ProceduralSkyTextureData::skyCurve() const
{
    return m_skyCurve;
}
 
float ProceduralSkyTextureData::skyEnergy() const
{
    return m_skyEnergy;
}
 
QColor ProceduralSkyTextureData::groundBottomColor() const
{
    return m_groundBottomColor;
}
 
QColor ProceduralSkyTextureData::groundHorizonColor() const
{
    return m_groundHorizonColor;
}
 
float ProceduralSkyTextureData::groundCurve() const
{
    return m_groundCurve;
}
 
float ProceduralSkyTextureData::groundEnergy() const
{
    return m_groundEnergy;
}
 
QColor ProceduralSkyTextureData::sunColor() const
{
    return m_sunColor;
}
 
float ProceduralSkyTextureData::sunLatitude() const
{
    return m_sunLatitude;
}
 
float ProceduralSkyTextureData::sunLongitude() const
{
    return m_sunLongitude;
}
 
float ProceduralSkyTextureData::sunAngleMin() const
{
    return m_sunAngleMin;
}
 
float ProceduralSkyTextureData::sunAngleMax() const
{
    return m_sunAngleMax;
}
 
float ProceduralSkyTextureData::sunCurve() const
{
    return m_sunCurve;
}
 
float ProceduralSkyTextureData::sunEnergy() const
{
    return m_sunEnergy;
}
 
ProceduralSkyTextureData::SkyTextureQuality ProceduralSkyTextureData::textureQuality() const
{
    return m_textureQuality;
}
 
void ProceduralSkyTextureData::setSkyTopColor(QColor skyTopColor)
{
    if (m_skyTopColor == skyTopColor)
        return;
 
    m_skyTopColor = skyTopColor;
    emit skyTopColorChanged(m_skyTopColor);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSkyHorizonColor(QColor skyHorizonColor)
{
    if (m_skyHorizonColor == skyHorizonColor)
        return;
 
    m_skyHorizonColor = skyHorizonColor;
    emit skyHorizonColorChanged(m_skyHorizonColor);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSkyCurve(float skyCurve)
{
    if (qFuzzyCompare(m_skyCurve, skyCurve))
        return;
 
    m_skyCurve = skyCurve;
    emit skyCurveChanged(m_skyCurve);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSkyEnergy(float skyEnergy)
{
    if (qFuzzyCompare(m_skyEnergy, skyEnergy))
        return;
 
    m_skyEnergy = skyEnergy;
    emit skyEnergyChanged(m_skyEnergy);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setGroundBottomColor(QColor groundBottomColor)
{
    if (m_groundBottomColor == groundBottomColor)
        return;
 
    m_groundBottomColor = groundBottomColor;
    emit groundBottomColorChanged(m_groundBottomColor);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setGroundHorizonColor(QColor groundHorizonColor)
{
    if (m_groundHorizonColor == groundHorizonColor)
        return;
 
    m_groundHorizonColor = groundHorizonColor;
    emit groundHorizonColorChanged(m_groundHorizonColor);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setGroundCurve(float groundCurve)
{
    if (qFuzzyCompare(m_groundCurve, groundCurve))
        return;
 
    m_groundCurve = groundCurve;
    emit groundCurveChanged(m_groundCurve);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setGroundEnergy(float groundEnergy)
{
    if (qFuzzyCompare(m_groundEnergy, groundEnergy))
        return;
 
    m_groundEnergy = groundEnergy;
    emit groundEnergyChanged(m_groundEnergy);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunColor(QColor sunColor)
{
    if (m_sunColor == sunColor)
        return;
 
    m_sunColor = sunColor;
    emit sunColorChanged(m_sunColor);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunLatitude(float sunLatitude)
{
    if (qFuzzyCompare(m_sunLatitude, sunLatitude))
        return;
 
    m_sunLatitude = sunLatitude;
    emit sunLatitudeChanged(m_sunLatitude);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunLongitude(float sunLongitude)
{
    if (qFuzzyCompare(m_sunLongitude, sunLongitude))
        return;
 
    m_sunLongitude = sunLongitude;
    emit sunLongitudeChanged(m_sunLongitude);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunAngleMin(float sunAngleMin)
{
    if (qFuzzyCompare(m_sunAngleMin, sunAngleMin))
        return;
 
    m_sunAngleMin = sunAngleMin;
    emit sunAngleMinChanged(m_sunAngleMin);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunAngleMax(float sunAngleMax)
{
    if (qFuzzyCompare(m_sunAngleMax, sunAngleMax))
        return;
 
    m_sunAngleMax = sunAngleMax;
    emit sunAngleMaxChanged(m_sunAngleMax);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunCurve(float sunCurve)
{
    if (qFuzzyCompare(m_sunCurve, sunCurve))
        return;
 
    m_sunCurve = sunCurve;
    emit sunCurveChanged(m_sunCurve);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setSunEnergy(float sunEnergy)
{
    if (qFuzzyCompare(m_sunEnergy, sunEnergy))
        return;
 
    m_sunEnergy = sunEnergy;
    emit sunEnergyChanged(m_sunEnergy);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::setTextureQuality(ProceduralSkyTextureData::SkyTextureQuality textureQuality)
{
    if (m_textureQuality == textureQuality)
        return;
 
    m_textureQuality = textureQuality;
    emit textureQualityChanged(m_textureQuality);
    scheduleTextureUpdate();
}
 
void ProceduralSkyTextureData::generateRGBA16FTexture()
{
    int size = 0;
    switch (m_textureQuality) {
    case SkyTextureQuality::SkyTextureQualityLow:
        size = 512;
        break;
    case SkyTextureQuality::SkyTextureQualityMedium:
        size = 1024;
        break;
    case SkyTextureQuality::SkyTextureQualityHigh:
        size = 2048;
        break;
    case SkyTextureQuality::SkyTextureQualityVeryHigh:
        size = 4096;
        break;
    }
 
    const int width = size;
    const int height = width / 2;
    setSize(QSize(width, height));
    setFormat(Format::RGBA16F);
    setHasTransparency(false);
    const int dataSize = width * height * 4 * 2; // 2 bytes per channel
    QByteArray imageData;
    imageData.resize(dataSize);
    generateSkyTexture(width, height, imageData, false);
    setTextureData(imageData);
}
 
QByteArray ProceduralSkyTextureData::generateSkyTexture(int width, int height, QByteArray &imageData, bool isRGBE) const
{
    quint32 *data = reinterpret_cast<quint32 *>(imageData.data());
 
    LinearColor skyTopLinear(m_skyTopColor);
    LinearColor skyHorizonLinear(m_skyHorizonColor);
    LinearColor groundBottomLinear(m_groundBottomColor);
    LinearColor groundHorizonLinear(m_groundHorizonColor);
    LinearColor sunLinear(m_sunColor);
    sunLinear.r *= m_sunEnergy;
    sunLinear.g *= m_sunEnergy;
    sunLinear.b *= m_sunEnergy;
 
    QVector3D sun(0, 0, -1);
 
    sun = QQuaternion::fromAxisAndAngle(QVector3D(1, 0, 0), m_sunLatitude) * sun;
    sun = QQuaternion::fromAxisAndAngle(QVector3D(0, 1, 0), m_sunLongitude) * sun;
    sun.normalize();
 
    auto clamp = [](float value, float min, float max) {
        if (value < min)
            return min;
        else if (value > max)
            return max;
        return value;
    };
 
    auto ease = [](float x, float c) {
        if (x < 0.0f)
            x = 0.0f;
        else if (x > 1.0f)
            x = 1.0f;
        if (c > 0.0f) {
            if (c < 1.0f) {
                return 1.0f - qPow(1.0f - x, 1.0f / c);
            } else {
                return qPow(x, c);
            }
        } else if (c < 0.0f) {
            if (x < 0.5f) {
                return qPow(x * 2.0f, -c) * 0.5f;
            } else {
                return (1.0f - qPow(1.0f - (x - 0.5f) * 2.0f, -c)) * 0.5f + 0.5f;
            }
        } else
            return 0.0f;
    };
 
    for (int i = 0; i < width; i++) {
 
        float u = float(i) / (width - 1);
        float phi = u * 2.0 * M_PI;
 
        for (int j = 0; j < height; j++) {
            float v = float(j) / (height - 1);
            float theta = v * M_PI;
 
            QVector3D normal(qSin(phi) * qSin(theta) * -1.0,
                             qCos(theta),
                             qCos(phi) * qSin(theta) * -1.0);
            normal.normalize();
            float vAngle = qAcos(clamp(normal.y(), -1.0, 1.0));
            LinearColor color;
 
            if (normal.y() < 0) {
                // Ground color
                float c = (vAngle - (M_PI * 0.5f)) / (M_PI * 0.5f);
                color = groundHorizonLinear.interpolate(groundBottomLinear, ease(c, m_groundCurve));
                color.r *= m_groundEnergy;
                color.g *= m_groundEnergy;
                color.b *= m_groundEnergy;
            } else {
                // Sky color
                float c = vAngle / (M_PI * 0.5f);
                color = skyHorizonLinear.interpolate(skyTopLinear, ease(1.0 - c, m_skyCurve));
                color.r *= m_skyEnergy;
                color.g *= m_skyEnergy;
                color.b *= m_skyEnergy;
 
                float sunAngle = qRadiansToDegrees(qAcos(clamp(QVector3D::dotProduct(sun, normal), -1.0f, 1.0f)));
                if (sunAngle < m_sunAngleMin) {
                    color = color.blend(sunLinear);
                } else if (sunAngle < m_sunAngleMax) {
                    float c2 = (sunAngle - m_sunAngleMin) / (m_sunAngleMax - m_sunAngleMin);
                    c2 = ease(c2, m_sunCurve);
                    color = color.blend(sunLinear).interpolate(color, c2);
                }
            }
 
            // Write from bottom to top
            if (isRGBE) {
                data[(height - j - 1) * width + i] = color.toRGBE8();
            } else {
                // RGBA16F
                const int offset = ((height - j - 1) * width + i) * 2;
                qfloat16 *fData = reinterpret_cast<qfloat16 *>(data + offset);
                float pixel[4] = {color.r, color.g, color.b, color.a };
                qFloatToFloat16(fData, pixel, 4);
            }
        }
    }
 
    return imageData;
}
 
void ProceduralSkyTextureData::scheduleTextureUpdate()
{
    generateRGBA16FTexture();
}
 
ProceduralSkyTextureData::LinearColor::LinearColor(const QColor &color)
{
    const float red = color.redF();
    const float green = color.greenF();
    const float blue = color.blueF();
    const float alpha = color.alphaF();
 
    r = red < 0.04045 ? red * (1.0 / 12.92) : qPow((red + 0.055) * (1.0 / (1 + 0.055)), 2.4),
    g = green < 0.04045 ? green * (1.0 / 12.92) : qPow((green + 0.055) * (1.0 / (1 + 0.055)), 2.4),
    b = blue < 0.04045 ? blue * (1.0 / 12.92) : qPow((blue + 0.055) * (1.0 / (1 + 0.055)), 2.4),
    a = alpha;
}
 
ProceduralSkyTextureData::LinearColor ProceduralSkyTextureData::LinearColor::interpolate(const ProceduralSkyTextureData::LinearColor &color, float value) const
{
    LinearColor copy = *this;
 
    copy.r += (value * (color.r - r));
    copy.g += (value * (color.g - g));
    copy.b += (value * (color.b - b));
    copy.a += (value * (color.a - a));
 
    return copy;
}
 
ProceduralSkyTextureData::LinearColor ProceduralSkyTextureData::LinearColor::blend(const ProceduralSkyTextureData::LinearColor &color) const
{
    LinearColor copy;
    float sa = 1.0 - color.a;
    copy.a = a * sa + color.a;
    if (copy.a == 0) {
        return LinearColor();
    } else {
        copy.r = (r * a * sa + color.r * color.a) / copy.a;
        copy.g = (g * a * sa + color.g * color.a) / copy.a;
        copy.b = (b * a * sa + color.b * color.a) / copy.a;
    }
    return copy;
}
 
quint32 ProceduralSkyTextureData::LinearColor::toRGBA8() const
{
    return (quint32(lrintf(r)) & 0xFF) |
           ((quint32(lrintf(g)) & 0xFF) << 8) |
           ((quint32(lrintf(b)) & 0xFF) << 16) |
            ((quint32(lrintf(a)) & 0xFF) << 24);
}
 
quint32 ProceduralSkyTextureData::LinearColor::toRGBE8() const
{
    float v = 0.0f;
    int exp = 0;
 
    v = r;
    if (g > v)
        v = g;
    if (b > v)
        v = b;
 
    v = frexp(v, &exp) * 256.0f / v;
    quint32 result = 0;
    quint8 *components = reinterpret_cast<quint8*>(&result);
    components[0] = quint8(r * v);
    components[1] = quint8(g * v);
    components[2] = quint8(b * v);
    components[3] = quint8(exp + 128);
    return result;
}
 
quint32 ProceduralSkyTextureData::LinearColor::toRGBE9995() const
{
    const float pow2to9 = 512.0f;
    const float B = 15.0f;
    const float N = 9.0f;
 
    float sharedExp = 65408.000f;
 
    float cRed = qMax(0.0f, qMin(sharedExp, r));
    float cGreen = qMax(0.0f, qMin(sharedExp, g));
    float cBlue = qMax(0.0f, qMin(sharedExp, b));
 
    float cMax = qMax(cRed, qMax(cGreen, cBlue));
 
    float expp = qMax(-B - 1.0f, floor(std::log(cMax) / M_LN2)) + 1.0f + B;
 
    float sMax = (float)floor((cMax / qPow(2.0f, expp - B - N)) + 0.5f);
 
    float exps = expp + 1.0f;
 
    if (0.0 <= sMax && sMax < pow2to9) {
        exps = expp;
    }
 
    float sRed = qFloor((cRed / pow(2.0f, exps - B - N)) + 0.5f);
    float sGreen = qFloor((cGreen / pow(2.0f, exps - B - N)) + 0.5f);
    float sBlue = qFloor((cBlue / pow(2.0f, exps - B - N)) + 0.5f);
 
    return (quint32(lrintf(sRed)) & 0x1FF) |
           ((quint32(lrintf(sGreen)) & 0x1FF) << 9) |
           ((quint32(lrintf(sBlue)) & 0x1FF) << 18) |
           ((quint32(lrintf(exps)) & 0x1F) << 27);
}
 
QT_END_NAMESPACE