iestexturedata.cpp

Enable keyboard shortcuts

// Copyright (C) 2026 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

#include "iestexturedata.h"

#include <QFile>

#include <QTextStream>

#include <QtMath>

#include <QPair>

#include <QSize>

#include <QQmlContext>

IESTextureData::IESTextureData(QQuick3DObject *parent)

    : QQuick3DTextureData(parent)

    setFormat(QQuick3DTextureData::R16F);

    setHasTransparency(false);

QList<QUrl> IESTextureData::sources() const { return m_sources; }

void IESTextureData::setSources(const QList<QUrl> &sources)

    if (m_sources != sources) {

        m_sources = sources;

        parseIESFiles();

        emit sourcesChanged();

void IESTextureData::parseIESFiles()

    if (m_sources.isEmpty()) { qWarning() << "No IES files provided"; return; }

    QVector<IESData> dataList;

    dataList.reserve(m_sources.size());

    for (const QUrl &source : std::as_const(m_sources)) {

        IESData data = parseIESFile(source);

        if (data.numVerticalAngles > 0 && data.numHorizontalAngles > 0)

            dataList.append(data);

    if (dataList.isEmpty()) { qWarning() << "No valid IES files could be parsed"; return; }

    generateTexture(dataList);

IESTextureData::IESData IESTextureData::parseIESFile(const QUrl &source)

    QUrl resolvedSource = qmlContext(this)->parentContext()->resolvedUrl(source);

    QString path = resolvedSource.scheme() == "qrc" ? ":" + resolvedSource.path() :

                       resolvedSource.toLocalFile().isEmpty() ? resolvedSource.path() : resolvedSource.toLocalFile();

    QFile file(path);

    IESData data;

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {

        qWarning() << "Cannot open IES file:" << resolvedSource << path;

        return data;

    QTextStream in(&file);

    in.setEncoding(QStringConverter::Utf8);

    while (!in.atEnd() && !in.readLine().trimmed().startsWith("TILT="));

    if (in.atEnd()) return data;

    auto params = readFloats(in, 10);

    if (params.size() < 10) return data;

    data.numVerticalAngles   = params[3];

    data.numHorizontalAngles = params[4];

    data.candelaMultiplier   = params[2];

    readFloats(in, 3);

    data.verticalAngles   = readFloats(in, data.numVerticalAngles);

    data.horizontalAngles = readFloats(in, data.numHorizontalAngles);

    data.candelaValues.resize(data.numHorizontalAngles);

    data.maxCandela = 0.0f;

    for (int h = 0; h < data.numHorizontalAngles; ++h) {

        data.candelaValues[h] = readFloats(in, data.numVerticalAngles);

        for (const float &v : data.candelaValues.at(h))

            data.maxCandela = qMax(data.maxCandela, v * data.candelaMultiplier);

    return data;

QVector<float> IESTextureData::readFloats(QTextStream &in, int count)

    QVector<float> vals;

    vals.reserve(count);

    while (vals.size() < count && !in.atEnd()) {

        auto sd = in.readLine().split(' ', Qt::SkipEmptyParts);

        for (const QString &s : std::as_const(sd)) {

            bool ok;

            float f = s.toFloat(&ok);

            if (ok && vals.size() < count) vals.append(f);

    return vals;

static void octToDir(float u, float v, float &dx, float &dy, float &dz)

    float ox = u * 2.0f - 1.0f;

    float oy = v * 2.0f - 1.0f;

    float oz = 1.0f - qAbs(ox) - qAbs(oy);

    if (oz < 0.0f) {

        float tx = ox, ty = oy;

        ox = (1.0f - qAbs(ty)) * (tx >= 0.0f ? 1.0f : -1.0f);

        oy = (1.0f - qAbs(tx)) * (ty >= 0.0f ? 1.0f : -1.0f);

    float len = qSqrt(ox*ox + oy*oy + oz*oz);

    dx = ox / len;

    dy = oy / len;

    dz = oz / len;

void IESTextureData::generateTexture(const QVector<IESData> &dataList)

    const int sliceW = 254;

    const int sliceH = 254;

    const int padding = 1;

    const int paddedW = sliceW + padding * 2;

    const int count = dataList.size();

    const int totalW = paddedW * count;

    const int totalH = sliceH + padding * 2;

    QByteArray texData;

    texData.resize(totalW * totalH * sizeof(qfloat16));

    qfloat16 *ptr = reinterpret_cast<qfloat16*>(texData.data());

    memset(texData.data(), 0, texData.size());

    const float RAD2DEG = 180.0f / static_cast<float>(M_PI);

    for (int z = 0; z < count; ++z) {

        const IESData &data = dataList[z];

        float maxVal = data.maxCandela > 0 ? data.maxCandela : 1.0f;

        int xOff = z * paddedW + padding;

        int yOff = padding;

        auto writeTexel = [&](int tx, int ty, float intensity) {

            int idx = ty * totalW + tx;

            ptr[idx] = qfloat16(qBound(0.0f, intensity / maxVal, 1.0f));

};

        for (int py = 0; py < sliceH; ++py) {

            float v = (py + 0.5f) / sliceH;

            for (int px = 0; px < sliceW; ++px) {

                float u = (px + 0.5f) / sliceW;

                float dx, dy, dz;

                octToDir(u, v, dx, dy, dz);

                float theta = qAcos(qBound(-1.0f, dz, 1.0f)) * RAD2DEG;

                float phi = qAtan2(dy, dx) * RAD2DEG;

                if (phi < 0.0f) phi += 360.0f;

                writeTexel(xOff + px, yOff + py,

                           getIntensity(data, theta, phi));

        for (int py = 0; py < sliceH; ++py) {

            ptr[(yOff + py) * totalW + (xOff - 1)]        = ptr[(yOff + py) * totalW + (xOff + sliceW - 1)];

            ptr[(yOff + py) * totalW + (xOff + sliceW)]   = ptr[(yOff + py) * totalW + xOff];

        int rowLen = paddedW;

        for (int px = -1; px < sliceW + 1; ++px) {

            ptr[(yOff - 1)       * totalW + (xOff + px)] = ptr[(yOff + sliceH - 1) * totalW + (xOff + px)];

            ptr[(yOff + sliceH)  * totalW + (xOff + px)] = ptr[yOff               * totalW + (xOff + px)];

        (void)rowLen;

    setTextureData(texData);

    setSize(QSize(totalW, totalH));

float IESTextureData::getIntensity(const IESData &data, float theta, float phi) const

    theta = qBound(data.verticalAngles.first(), theta, data.verticalAngles.last());

    while (phi < 0)    phi += 360;

    while (phi >= 360) phi -= 360;

    if (phi < 90)       phi = 180 - phi;

    else if (phi > 270) phi = 540 - phi;

    phi = qBound(data.horizontalAngles.first(), phi, data.horizontalAngles.last());

    auto lerp = [&](const QVector<float> &arr, float val) -> QPair<int, float> {

        for (int i = 0; i < arr.size() - 1; ++i)

            if (val <= arr[i + 1])

                return qMakePair(i, (val - arr[i]) / (arr[i + 1] - arr[i]));

        return qMakePair(int(arr.size() - 1), 0.0f);

};

    auto [v0, vt] = lerp(data.verticalAngles,   theta);

    auto [h0, ht] = lerp(data.horizontalAngles, phi);

    int v1 = qMin(v0 + 1, data.verticalAngles.size()   - 1);

    int h1 = qMin(h0 + 1, data.horizontalAngles.size() - 1);

    float i00 = data.candelaValues[h0][v0] * data.candelaMultiplier;

    float i01 = data.candelaValues[h0][v1] * data.candelaMultiplier;

    float i10 = data.candelaValues[h1][v0] * data.candelaMultiplier;

    float i11 = data.candelaValues[h1][v1] * data.candelaMultiplier;

    return (i00 * (1 - vt) + i01 * vt) * (1 - ht) + (i10 * (1 - vt) + i11 * vt) * ht;