ui_pqLightsEditor.h

Go to the documentation of this file.

/********************************************************************************
** Form generated from reading UI file 'pqLightsEditor.ui'
**
** Created by: Qt User Interface Compiler version 5.15.2
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_PQLIGHTSEDITOR_H
#define UI_PQLIGHTSEDITOR_H

#include <QtCore/QVariant>
#include <QtWidgets/QApplication>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>

QT_BEGIN_NAMESPACE

class Ui_LightsEditor
{
public:
    QVBoxLayout *verticalLayout;
    QWidget *LightKitControls;
    QHBoxLayout *anotherHBoxLayout;
    QCheckBox *LightKit;
    QPushButton *Reset;
    QWidget *lightKitParams;
    QGridLayout *gridLayout;
    QLabel *backLabel;
    QDoubleSpinBox *HeadLightK_H_Ratio;
    QLabel *fillWarmthLabel;
    QLabel *fillAzimuthLabel;
    QLabel *keyAzimuthLabel;
    QDoubleSpinBox *BackLightElevation;
    QDoubleSpinBox *KeyLightIntensity;
    QDoubleSpinBox *BackLightK_B_Ratio;
    QLabel *headWarmthLabel;
    QDoubleSpinBox *KeyLightWarmth;
    QLabel *fillLabel;
    QDoubleSpinBox *FillLightAzimuth;
    QDoubleSpinBox *FillLightElevation;
    QDoubleSpinBox *KeyLightElevation;
    QLabel *keyLabel;
    QDoubleSpinBox *KeyLightAzimuth;
    QLabel *headRatioLabel;
    QDoubleSpinBox *HeadLightWarmth;
    QLabel *fillElevationLabel;
    QLabel *fillRatioLabel;
    QLabel *keyIntensityLabel;
    QLabel *headLabel;
    QDoubleSpinBox *FillLightWarmth;
    QDoubleSpinBox *BackLightAzimuth;
    QLabel *backElevationLabel;
    QLabel *backRatioLabel;
    QLabel *keyElevationLabel;
    QLabel *keyWarmthLabel;
    QLabel *backWarmthLabel;
    QLabel *backAzimuthLabel;
    QCheckBox *MaintainLuminance;
    QDoubleSpinBox *BackLightWarmth;
    QDoubleSpinBox *FillLightK_F_Ratio;

    void setupUi(QWidget *LightsEditor)
    {
        if (LightsEditor->objectName().isEmpty())
            LightsEditor->setObjectName(QString::fromUtf8("LightsEditor"));
        LightsEditor->resize(439, 252);
        QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
        sizePolicy.setHorizontalStretch(0);
        sizePolicy.setVerticalStretch(0);
        sizePolicy.setHeightForWidth(LightsEditor->sizePolicy().hasHeightForWidth());
        LightsEditor->setSizePolicy(sizePolicy);
        verticalLayout = new QVBoxLayout(LightsEditor);
        verticalLayout->setObjectName(QString::fromUtf8("verticalLayout"));
        verticalLayout->setContentsMargins(0, 0, 0, 9);
        LightKitControls = new QWidget(LightsEditor);
        LightKitControls->setObjectName(QString::fromUtf8("LightKitControls"));
        LightKitControls->setMinimumSize(QSize(0, 0));
        anotherHBoxLayout = new QHBoxLayout(LightKitControls);
        anotherHBoxLayout->setObjectName(QString::fromUtf8("anotherHBoxLayout"));
        anotherHBoxLayout->setContentsMargins(0, 0, 0, 0);
        LightKit = new QCheckBox(LightKitControls);
        LightKit->setObjectName(QString::fromUtf8("LightKit"));
        LightKit->setChecked(true);

        anotherHBoxLayout->addWidget(LightKit);

        Reset = new QPushButton(LightKitControls);
        Reset->setObjectName(QString::fromUtf8("Reset"));

        anotherHBoxLayout->addWidget(Reset);


        verticalLayout->addWidget(LightKitControls);

        lightKitParams = new QWidget(LightsEditor);
        lightKitParams->setObjectName(QString::fromUtf8("lightKitParams"));
        gridLayout = new QGridLayout(lightKitParams);
        gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
        gridLayout->setContentsMargins(0, 0, 0, 0);
        backLabel = new QLabel(lightKitParams);
        backLabel->setObjectName(QString::fromUtf8("backLabel"));

        gridLayout->addWidget(backLabel, 3, 0, 1, 1);

        HeadLightK_H_Ratio = new QDoubleSpinBox(lightKitParams);
        HeadLightK_H_Ratio->setObjectName(QString::fromUtf8("HeadLightK_H_Ratio"));
        QSizePolicy sizePolicy1(QSizePolicy::Minimum, QSizePolicy::Fixed);
        sizePolicy1.setHorizontalStretch(1);
        sizePolicy1.setVerticalStretch(0);
        sizePolicy1.setHeightForWidth(HeadLightK_H_Ratio->sizePolicy().hasHeightForWidth());
        HeadLightK_H_Ratio->setSizePolicy(sizePolicy1);
        HeadLightK_H_Ratio->setMinimum(1.000000000000000);
        HeadLightK_H_Ratio->setSingleStep(0.500000000000000);

        gridLayout->addWidget(HeadLightK_H_Ratio, 4, 4, 1, 1);

        fillWarmthLabel = new QLabel(lightKitParams);
        fillWarmthLabel->setObjectName(QString::fromUtf8("fillWarmthLabel"));

        gridLayout->addWidget(fillWarmthLabel, 2, 1, 1, 1);

        fillAzimuthLabel = new QLabel(lightKitParams);
        fillAzimuthLabel->setObjectName(QString::fromUtf8("fillAzimuthLabel"));

        gridLayout->addWidget(fillAzimuthLabel, 2, 7, 1, 1);

        keyAzimuthLabel = new QLabel(lightKitParams);
        keyAzimuthLabel->setObjectName(QString::fromUtf8("keyAzimuthLabel"));

        gridLayout->addWidget(keyAzimuthLabel, 1, 7, 1, 1);

        BackLightElevation = new QDoubleSpinBox(lightKitParams);
        BackLightElevation->setObjectName(QString::fromUtf8("BackLightElevation"));
        sizePolicy1.setHeightForWidth(BackLightElevation->sizePolicy().hasHeightForWidth());
        BackLightElevation->setSizePolicy(sizePolicy1);
        BackLightElevation->setDecimals(0);
        BackLightElevation->setMinimum(-90.000000000000000);
        BackLightElevation->setMaximum(90.000000000000000);
        BackLightElevation->setSingleStep(10.000000000000000);

        gridLayout->addWidget(BackLightElevation, 3, 6, 1, 1);

        KeyLightIntensity = new QDoubleSpinBox(lightKitParams);
        KeyLightIntensity->setObjectName(QString::fromUtf8("KeyLightIntensity"));
        sizePolicy1.setHeightForWidth(KeyLightIntensity->sizePolicy().hasHeightForWidth());
        KeyLightIntensity->setSizePolicy(sizePolicy1);
        KeyLightIntensity->setMaximum(1.000000000000000);
        KeyLightIntensity->setSingleStep(0.100000000000000);

        gridLayout->addWidget(KeyLightIntensity, 1, 4, 1, 1);

        BackLightK_B_Ratio = new QDoubleSpinBox(lightKitParams);
        BackLightK_B_Ratio->setObjectName(QString::fromUtf8("BackLightK_B_Ratio"));
        sizePolicy1.setHeightForWidth(BackLightK_B_Ratio->sizePolicy().hasHeightForWidth());
        BackLightK_B_Ratio->setSizePolicy(sizePolicy1);
        BackLightK_B_Ratio->setMinimum(1.000000000000000);
        BackLightK_B_Ratio->setSingleStep(0.500000000000000);

        gridLayout->addWidget(BackLightK_B_Ratio, 3, 4, 1, 1);

        headWarmthLabel = new QLabel(lightKitParams);
        headWarmthLabel->setObjectName(QString::fromUtf8("headWarmthLabel"));

        gridLayout->addWidget(headWarmthLabel, 4, 1, 1, 1);

        KeyLightWarmth = new QDoubleSpinBox(lightKitParams);
        KeyLightWarmth->setObjectName(QString::fromUtf8("KeyLightWarmth"));
        sizePolicy1.setHeightForWidth(KeyLightWarmth->sizePolicy().hasHeightForWidth());
        KeyLightWarmth->setSizePolicy(sizePolicy1);
        KeyLightWarmth->setButtonSymbols(QAbstractSpinBox::UpDownArrows);
        KeyLightWarmth->setMaximum(1.000000000000000);
        KeyLightWarmth->setSingleStep(0.100000000000000);

        gridLayout->addWidget(KeyLightWarmth, 1, 2, 1, 1);

        fillLabel = new QLabel(lightKitParams);
        fillLabel->setObjectName(QString::fromUtf8("fillLabel"));

        gridLayout->addWidget(fillLabel, 2, 0, 1, 1);

        FillLightAzimuth = new QDoubleSpinBox(lightKitParams);
        FillLightAzimuth->setObjectName(QString::fromUtf8("FillLightAzimuth"));
        sizePolicy1.setHeightForWidth(FillLightAzimuth->sizePolicy().hasHeightForWidth());
        FillLightAzimuth->setSizePolicy(sizePolicy1);
        FillLightAzimuth->setDecimals(0);
        FillLightAzimuth->setMinimum(-180.000000000000000);
        FillLightAzimuth->setMaximum(180.000000000000000);
        FillLightAzimuth->setSingleStep(10.000000000000000);

        gridLayout->addWidget(FillLightAzimuth, 2, 8, 1, 1);

        FillLightElevation = new QDoubleSpinBox(lightKitParams);
        FillLightElevation->setObjectName(QString::fromUtf8("FillLightElevation"));
        sizePolicy1.setHeightForWidth(FillLightElevation->sizePolicy().hasHeightForWidth());
        FillLightElevation->setSizePolicy(sizePolicy1);
        FillLightElevation->setDecimals(0);
        FillLightElevation->setMinimum(-90.000000000000000);
        FillLightElevation->setMaximum(90.000000000000000);
        FillLightElevation->setSingleStep(10.000000000000000);

        gridLayout->addWidget(FillLightElevation, 2, 6, 1, 1);

        KeyLightElevation = new QDoubleSpinBox(lightKitParams);
        KeyLightElevation->setObjectName(QString::fromUtf8("KeyLightElevation"));
        sizePolicy1.setHeightForWidth(KeyLightElevation->sizePolicy().hasHeightForWidth());
        KeyLightElevation->setSizePolicy(sizePolicy1);
        KeyLightElevation->setDecimals(0);
        KeyLightElevation->setMinimum(-90.000000000000000);
        KeyLightElevation->setMaximum(90.000000000000000);
        KeyLightElevation->setSingleStep(10.000000000000000);

        gridLayout->addWidget(KeyLightElevation, 1, 6, 1, 1);

        keyLabel = new QLabel(lightKitParams);
        keyLabel->setObjectName(QString::fromUtf8("keyLabel"));

        gridLayout->addWidget(keyLabel, 1, 0, 1, 1);

        KeyLightAzimuth = new QDoubleSpinBox(lightKitParams);
        KeyLightAzimuth->setObjectName(QString::fromUtf8("KeyLightAzimuth"));
        sizePolicy1.setHeightForWidth(KeyLightAzimuth->sizePolicy().hasHeightForWidth());
        KeyLightAzimuth->setSizePolicy(sizePolicy1);
        KeyLightAzimuth->setDecimals(0);
        KeyLightAzimuth->setMinimum(-180.000000000000000);
        KeyLightAzimuth->setMaximum(180.000000000000000);
        KeyLightAzimuth->setSingleStep(10.000000000000000);

        gridLayout->addWidget(KeyLightAzimuth, 1, 8, 1, 1);

        headRatioLabel = new QLabel(lightKitParams);
        headRatioLabel->setObjectName(QString::fromUtf8("headRatioLabel"));

        gridLayout->addWidget(headRatioLabel, 4, 3, 1, 1);

        HeadLightWarmth = new QDoubleSpinBox(lightKitParams);
        HeadLightWarmth->setObjectName(QString::fromUtf8("HeadLightWarmth"));
        sizePolicy1.setHeightForWidth(HeadLightWarmth->sizePolicy().hasHeightForWidth());
        HeadLightWarmth->setSizePolicy(sizePolicy1);
        HeadLightWarmth->setMaximum(1.000000000000000);
        HeadLightWarmth->setSingleStep(0.100000000000000);

        gridLayout->addWidget(HeadLightWarmth, 4, 2, 1, 1);

        fillElevationLabel = new QLabel(lightKitParams);
        fillElevationLabel->setObjectName(QString::fromUtf8("fillElevationLabel"));

        gridLayout->addWidget(fillElevationLabel, 2, 5, 1, 1);

        fillRatioLabel = new QLabel(lightKitParams);
        fillRatioLabel->setObjectName(QString::fromUtf8("fillRatioLabel"));

        gridLayout->addWidget(fillRatioLabel, 2, 3, 1, 1);

        keyIntensityLabel = new QLabel(lightKitParams);
        keyIntensityLabel->setObjectName(QString::fromUtf8("keyIntensityLabel"));

        gridLayout->addWidget(keyIntensityLabel, 1, 3, 1, 1);

        headLabel = new QLabel(lightKitParams);
        headLabel->setObjectName(QString::fromUtf8("headLabel"));

        gridLayout->addWidget(headLabel, 4, 0, 1, 1);

        FillLightWarmth = new QDoubleSpinBox(lightKitParams);
        FillLightWarmth->setObjectName(QString::fromUtf8("FillLightWarmth"));
        sizePolicy1.setHeightForWidth(FillLightWarmth->sizePolicy().hasHeightForWidth());
        FillLightWarmth->setSizePolicy(sizePolicy1);
        FillLightWarmth->setMaximum(1.000000000000000);
        FillLightWarmth->setSingleStep(0.100000000000000);

        gridLayout->addWidget(FillLightWarmth, 2, 2, 1, 1);

        BackLightAzimuth = new QDoubleSpinBox(lightKitParams);
        BackLightAzimuth->setObjectName(QString::fromUtf8("BackLightAzimuth"));
        sizePolicy1.setHeightForWidth(BackLightAzimuth->sizePolicy().hasHeightForWidth());
        BackLightAzimuth->setSizePolicy(sizePolicy1);
        BackLightAzimuth->setDecimals(0);
        BackLightAzimuth->setMinimum(-180.000000000000000);
        BackLightAzimuth->setMaximum(180.000000000000000);
        BackLightAzimuth->setSingleStep(10.000000000000000);

        gridLayout->addWidget(BackLightAzimuth, 3, 8, 1, 1);

        backElevationLabel = new QLabel(lightKitParams);
        backElevationLabel->setObjectName(QString::fromUtf8("backElevationLabel"));

        gridLayout->addWidget(backElevationLabel, 3, 5, 1, 1);

        backRatioLabel = new QLabel(lightKitParams);
        backRatioLabel->setObjectName(QString::fromUtf8("backRatioLabel"));

        gridLayout->addWidget(backRatioLabel, 3, 3, 1, 1);

        keyElevationLabel = new QLabel(lightKitParams);
        keyElevationLabel->setObjectName(QString::fromUtf8("keyElevationLabel"));

        gridLayout->addWidget(keyElevationLabel, 1, 5, 1, 1);

        keyWarmthLabel = new QLabel(lightKitParams);
        keyWarmthLabel->setObjectName(QString::fromUtf8("keyWarmthLabel"));

        gridLayout->addWidget(keyWarmthLabel, 1, 1, 1, 1);

        backWarmthLabel = new QLabel(lightKitParams);
        backWarmthLabel->setObjectName(QString::fromUtf8("backWarmthLabel"));

        gridLayout->addWidget(backWarmthLabel, 3, 1, 1, 1);

        backAzimuthLabel = new QLabel(lightKitParams);
        backAzimuthLabel->setObjectName(QString::fromUtf8("backAzimuthLabel"));

        gridLayout->addWidget(backAzimuthLabel, 3, 7, 1, 1);

        MaintainLuminance = new QCheckBox(lightKitParams);
        MaintainLuminance->setObjectName(QString::fromUtf8("MaintainLuminance"));

        gridLayout->addWidget(MaintainLuminance, 5, 0, 1, 4);

        BackLightWarmth = new QDoubleSpinBox(lightKitParams);
        BackLightWarmth->setObjectName(QString::fromUtf8("BackLightWarmth"));
        sizePolicy1.setHeightForWidth(BackLightWarmth->sizePolicy().hasHeightForWidth());
        BackLightWarmth->setSizePolicy(sizePolicy1);
        BackLightWarmth->setMaximum(1.000000000000000);
        BackLightWarmth->setSingleStep(0.100000000000000);

        gridLayout->addWidget(BackLightWarmth, 3, 2, 1, 1);

        FillLightK_F_Ratio = new QDoubleSpinBox(lightKitParams);
        FillLightK_F_Ratio->setObjectName(QString::fromUtf8("FillLightK_F_Ratio"));
        sizePolicy1.setHeightForWidth(FillLightK_F_Ratio->sizePolicy().hasHeightForWidth());
        FillLightK_F_Ratio->setSizePolicy(sizePolicy1);
        FillLightK_F_Ratio->setMinimum(1.000000000000000);
        FillLightK_F_Ratio->setSingleStep(0.500000000000000);

        gridLayout->addWidget(FillLightK_F_Ratio, 2, 4, 1, 1);


        verticalLayout->addWidget(lightKitParams);

        QWidget::setTabOrder(KeyLightWarmth, KeyLightIntensity);
        QWidget::setTabOrder(KeyLightIntensity, KeyLightElevation);
        QWidget::setTabOrder(KeyLightElevation, KeyLightAzimuth);
        QWidget::setTabOrder(KeyLightAzimuth, FillLightWarmth);
        QWidget::setTabOrder(FillLightWarmth, FillLightK_F_Ratio);
        QWidget::setTabOrder(FillLightK_F_Ratio, FillLightElevation);
        QWidget::setTabOrder(FillLightElevation, FillLightAzimuth);
        QWidget::setTabOrder(FillLightAzimuth, BackLightWarmth);
        QWidget::setTabOrder(BackLightWarmth, BackLightK_B_Ratio);
        QWidget::setTabOrder(BackLightK_B_Ratio, BackLightElevation);
        QWidget::setTabOrder(BackLightElevation, BackLightAzimuth);
        QWidget::setTabOrder(BackLightAzimuth, HeadLightWarmth);
        QWidget::setTabOrder(HeadLightWarmth, HeadLightK_H_Ratio);

        retranslateUi(LightsEditor);
        QObject::connect(LightKit, SIGNAL(toggled(bool)), lightKitParams, SLOT(setVisible(bool)));

        QMetaObject::connectSlotsByName(LightsEditor);
    } // setupUi

    void retranslateUi(QWidget *LightsEditor)
    {
        LightsEditor->setWindowTitle(QCoreApplication::translate("LightsEditor", "Lights Editor", nullptr));
#if QT_CONFIG(tooltip)
        LightKit->setToolTip(QCoreApplication::translate("LightsEditor", "Turn on or off all the lights in the lighting kit.", nullptr));
#endif // QT_CONFIG(tooltip)
        LightKit->setText(QCoreApplication::translate("LightsEditor", "Light Kit", nullptr));
#if QT_CONFIG(tooltip)
        Reset->setToolTip(QCoreApplication::translate("LightsEditor", "Reset lights to their default values", nullptr));
#endif // QT_CONFIG(tooltip)
        Reset->setText(QCoreApplication::translate("LightsEditor", "Reset", nullptr));
#if QT_CONFIG(tooltip)
        backLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The two back lights, one on the left of the object as seen from the observer and one on the right, fill on the high-contrast areas behind the object. ", nullptr));
#endif // QT_CONFIG(tooltip)
        backLabel->setText(QCoreApplication::translate("LightsEditor", "Back", nullptr));
#if QT_CONFIG(tooltip)
        HeadLightK_H_Ratio->setToolTip(QCoreApplication::translate("LightsEditor", "Set the Key-to-Head ratio. Similar to the Key-to-Fill ratio, this ratio controls how bright the headlight light is compared to the key light: larger values correspond to a dimmer headlight light. The headlight is special kind of fill light, lighting only the parts of the object that the camera can see. As such, a headlight tends to reduce the contrast of a scene. It can be used to fill in \"shadows\" of the object missed by the key and fill lights. The headlight should always be significantly dimmer than the key light: ratios of 2 to 15 are typical.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        fillWarmthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Fill Light. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
        fillWarmthLabel->setText(QCoreApplication::translate("LightsEditor", "Warm", nullptr));
#if QT_CONFIG(tooltip)
        fillAzimuthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Fill Light Azimuth. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
        fillAzimuthLabel->setText(QCoreApplication::translate("LightsEditor", "Azi", nullptr));
#if QT_CONFIG(tooltip)
        keyAzimuthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Key Light Azimuth. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
        keyAzimuthLabel->setText(QCoreApplication::translate("LightsEditor", "Azi", nullptr));
#if QT_CONFIG(tooltip)
        BackLightElevation->setToolTip(QCoreApplication::translate("LightsEditor", "The Back Light Elevation. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        KeyLightIntensity->setToolTip(QCoreApplication::translate("LightsEditor", "The Intensity of the Key Light.  0 = off and 1 = full intensity.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        BackLightK_B_Ratio->setToolTip(QCoreApplication::translate("LightsEditor", "Set the Key-to-Back Ratio. This ratio controls how bright the back lights are compared to the key light: larger values correspond to dimmer back lights. The back lights fill in the remaining high-contrast regions behind the object. Values between 2 and 10 are good.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        headWarmthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Headlight. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
        headWarmthLabel->setText(QCoreApplication::translate("LightsEditor", "Warm", nullptr));
#if QT_CONFIG(tooltip)
        KeyLightWarmth->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Key Light. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        fillLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Fill Light is usually positioned across from or opposite from the key light (though still on the same side of the object as the camera) in order to simulate diffuse reflections from other objects in the scene.", nullptr));
#endif // QT_CONFIG(tooltip)
        fillLabel->setText(QCoreApplication::translate("LightsEditor", "Fill", nullptr));
#if QT_CONFIG(tooltip)
        FillLightAzimuth->setToolTip(QCoreApplication::translate("LightsEditor", "The Fill Light Azimuth. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        FillLightElevation->setToolTip(QCoreApplication::translate("LightsEditor", "The Fill Light Elevation. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        KeyLightElevation->setToolTip(QCoreApplication::translate("LightsEditor", "The Key Light Elevation. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        keyLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Key Light is the main light.  It is usually positioned so that it appears like an overhead light (like the sun or a ceiling light).  It is generally positioned to shine down from about a 45 degree angle vertically and at least a little offset side to side.  The key light is usually at least about twice as bright as the total of all other lights in the scene to provide good modeling of object features.", nullptr));
#endif // QT_CONFIG(tooltip)
        keyLabel->setText(QCoreApplication::translate("LightsEditor", "Key", nullptr));
#if QT_CONFIG(tooltip)
        KeyLightAzimuth->setToolTip(QCoreApplication::translate("LightsEditor", "The Key Light Azimuth. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        headRatioLabel->setToolTip(QCoreApplication::translate("LightsEditor", "Set the Key-to-Head ratio. Similar to the Key-to-Fill ratio, this ratio controls how bright the headlight light is compared to the key light: larger values correspond to a dimmer headlight light. The headlight is special kind of fill light, lighting only the parts of the object that the camera can see. As such, a headlight tends to reduce the contrast of a scene. It can be used to fill in \"shadows\" of the object missed by the key and fill lights. The headlight should always be significantly dimmer than the key light: ratios of 2 to 15 are typical.", nullptr));
#endif // QT_CONFIG(tooltip)
        headRatioLabel->setText(QCoreApplication::translate("LightsEditor", "K:H", nullptr));
#if QT_CONFIG(tooltip)
        HeadLightWarmth->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Headlight. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        fillElevationLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Fill Light Elevation. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
        fillElevationLabel->setText(QCoreApplication::translate("LightsEditor", "Ele", nullptr));
#if QT_CONFIG(tooltip)
        fillRatioLabel->setToolTip(QCoreApplication::translate("LightsEditor", "Set the Key-to-Fill Ratio. This ratio controls how bright the fill light is compared to the key light: larger values correspond to a dimmer fill light. The purpose of the fill light is to light parts of the object not lit by the key light, while still maintaining contrast. This type of lighting may correspond to indirect illumination from the key light, bounced off a wall, floor, or other object. The fill light should never be brighter than the key light: a good range for the key-to-fill ratio is between 2 and 10.", nullptr));
#endif // QT_CONFIG(tooltip)
        fillRatioLabel->setText(QCoreApplication::translate("LightsEditor", "K:F", nullptr));
#if QT_CONFIG(tooltip)
        keyIntensityLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Intensity of the Key Light.  0 = off and 1 = full intensity.", nullptr));
#endif // QT_CONFIG(tooltip)
        keyIntensityLabel->setText(QCoreApplication::translate("LightsEditor", "Int", nullptr));
#if QT_CONFIG(tooltip)
        headLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The headlight, always located at the position of the camera, reduces the contrast between areas lit by the key and fill light. ", nullptr));
#endif // QT_CONFIG(tooltip)
        headLabel->setText(QCoreApplication::translate("LightsEditor", "Head", nullptr));
#if QT_CONFIG(tooltip)
        FillLightWarmth->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Fill Light. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        BackLightAzimuth->setToolTip(QCoreApplication::translate("LightsEditor", "The Back Light Azimuth. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        backElevationLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Back Light Elevation. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
        backElevationLabel->setText(QCoreApplication::translate("LightsEditor", "Ele", nullptr));
#if QT_CONFIG(tooltip)
        backRatioLabel->setToolTip(QCoreApplication::translate("LightsEditor", "Set the Key-to-Back Ratio. This ratio controls how bright the back lights are compared to the key light: larger values correspond to dimmer back lights. The back lights fill in the remaining high-contrast regions behind the object. Values between 2 and 10 are good.", nullptr));
#endif // QT_CONFIG(tooltip)
        backRatioLabel->setText(QCoreApplication::translate("LightsEditor", "K:B", nullptr));
#if QT_CONFIG(tooltip)
        keyElevationLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Key Light Elevation. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
        keyElevationLabel->setText(QCoreApplication::translate("LightsEditor", "Ele", nullptr));
#if QT_CONFIG(tooltip)
        keyWarmthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Key Light. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
        keyWarmthLabel->setText(QCoreApplication::translate("LightsEditor", "Warm", nullptr));
#if QT_CONFIG(tooltip)
        backWarmthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Back Light. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
        backWarmthLabel->setText(QCoreApplication::translate("LightsEditor", "Warm", nullptr));
#if QT_CONFIG(tooltip)
        backAzimuthLabel->setToolTip(QCoreApplication::translate("LightsEditor", "The Back Light Azimuth. For simplicity, the position of lights in the LightKit can only be specified using angles: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-clockwise. So, a light at (elevation=45, azimuth=-20) is above and in front of the object and shining slightly from the left side.", nullptr));
#endif // QT_CONFIG(tooltip)
        backAzimuthLabel->setText(QCoreApplication::translate("LightsEditor", "Azi", nullptr));
#if QT_CONFIG(tooltip)
        MaintainLuminance->setToolTip(QCoreApplication::translate("LightsEditor", "If Maintain Luminance is set, the LightKit will attempt to maintain the apparent intensity of lights based on their perceptual brightnesses.", nullptr));
#endif // QT_CONFIG(tooltip)
        MaintainLuminance->setText(QCoreApplication::translate("LightsEditor", "Maintain Luminance", nullptr));
#if QT_CONFIG(tooltip)
        BackLightWarmth->setToolTip(QCoreApplication::translate("LightsEditor", "The \"Warmth\" of the Back Light. Warmth is a parameter that varies from 0 to 1, where 0 is \"cold\" (looks icy or lit by a very blue sky), 1 is \"warm\" (the red of a very red sunset, or the embers of a campfire), and 0.5 is a neutral white. The warmth scale is non-linear. Warmth values close to 0.5 are subtly \"warmer\" or \"cooler,\" much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly. ", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        FillLightK_F_Ratio->setToolTip(QCoreApplication::translate("LightsEditor", "Set the Key-to-Fill Ratio. This ratio controls how bright the fill light is compared to the key light: larger values correspond to a dimmer fill light. The purpose of the fill light is to light parts of the object not lit by the key light, while still maintaining contrast. This type of lighting may correspond to indirect illumination from the key light, bounced off a wall, floor, or other object. The fill light should never be brighter than the key light: a good range for the key-to-fill ratio is between 2 and 10.", nullptr));
#endif // QT_CONFIG(tooltip)
    } // retranslateUi

};

namespace Ui {
    class LightsEditor: public Ui_LightsEditor {};
} // namespace Ui

QT_END_NAMESPACE

#endif // UI_PQLIGHTSEDITOR_H