terrain-gen/src/window.cpp

#include "window.h"

Window::Window(QWidget *parent) : QWidget(parent)
{
    QWidget *sidebar = new QWidget;
    m_glWidget = new GLWidget;

    QHBoxLayout *mainLayout = new QHBoxLayout;
    QVBoxLayout *sidebarLayout = new QVBoxLayout;

    createCameraInputs();
    createTerrainInputs();
    createSkyInputs();
    fillDefault();
    connectInputs();

    sidebarLayout->addWidget(m_cameraGroup);
    sidebarLayout->addWidget(m_terrainGroup);
    sidebarLayout->addWidget(m_skyGroup);
    sidebarLayout->addStretch();
    sidebar->setLayout(sidebarLayout);
    sidebar->setMaximumWidth(300);

    mainLayout->addWidget(m_glWidget);
    mainLayout->addWidget(sidebar);

    setLayout(mainLayout);
}

Window::~Window()
{
    delete m_cameraGroup;
    delete m_skyGroup;

    delete m_glWidget;
}

QDoubleSpinBox* Window::createDoubleSpinBox()
{
    QDoubleSpinBox* spinBox = new QDoubleSpinBox;
    spinBox->setSingleStep(0.1);
    spinBox->setRange(double(-std::numeric_limits<float>::max()), double(std::numeric_limits<float>::max()));
    return spinBox;
}

QWidget *Window::labelizeInput(QWidget* input, QString label)
{
    QWidget *container = new QWidget;
    QHBoxLayout *containerLayout = new QHBoxLayout;
    containerLayout->addWidget(new QLabel(label));
    containerLayout->addWidget(input);
    containerLayout->setMargin(0);
    container->setLayout(containerLayout);

    return container;
}

void Window::createCameraInputs()
{
    m_cameraGroup = new QGroupBox(tr("Camera"));
    QLabel *labelCameraPosition = new QLabel(tr("Position"));
    QLabel *labelCameraRotation = new QLabel(tr("Rotation"));

    m_cameraPosX = createDoubleSpinBox();
    m_cameraPosY = createDoubleSpinBox();
    m_cameraPosZ = createDoubleSpinBox();

    m_cameraRotX = createDoubleSpinBox();
    m_cameraRotY = createDoubleSpinBox();

    QVBoxLayout *cameraGroupLayout = new QVBoxLayout;

    cameraGroupLayout->addWidget(labelCameraPosition);

    cameraGroupLayout->addWidget(labelizeInput(m_cameraPosX, tr("X")));
    cameraGroupLayout->addWidget(labelizeInput(m_cameraPosY, tr("Y")));
    cameraGroupLayout->addWidget(labelizeInput(m_cameraPosZ, tr("Z")));

    cameraGroupLayout->addWidget(labelCameraRotation);

    cameraGroupLayout->addWidget(labelizeInput(m_cameraRotX, tr("Vertical")));
    cameraGroupLayout->addWidget(labelizeInput(m_cameraRotY, tr("Horizontal")));

    m_cameraGroup->setLayout(cameraGroupLayout);
}

void Window::updateCameraPosition(QVector3D newPosition)
{
    m_cameraPosX->setValue(double(newPosition.x()));
    m_cameraPosY->setValue(double(newPosition.y()));
    m_cameraPosZ->setValue(double(newPosition.z()));
}

void Window::createTerrainInputs()
{
    m_terrainGroup = new QGroupBox(tr("Terrain"));

    m_terrainShowNormals = new QCheckBox(tr("Show normals"));

    QVBoxLayout *terrainGroupLayout = new QVBoxLayout;
    terrainGroupLayout->addWidget(m_terrainShowNormals);
    m_terrainGroup->setLayout(terrainGroupLayout);
}

void Window::createSkyInputs()
{
    m_skyGroup = new QGroupBox(tr("Sky"));

    m_skyTimeSlider = new QSlider(Qt::Horizontal);
    m_skyInclinationSlider = new QSlider(Qt::Horizontal);
    m_skyAnimation = new QCheckBox(tr("Animate sky"));

    m_skyTimeHint = new QLabel;

    m_skyTimeSlider->setMaximum(1440);
    m_skyTimeSlider->setMinimum(0);
    m_skyTimeSlider->setTickInterval(60);
    m_skyTimeSlider->setTickPosition(QSlider::TicksBelow);

    m_skyInclinationSlider->setMaximum(180);
    m_skyInclinationSlider->setMinimum(0);
    m_skyInclinationSlider->setTickInterval(10);
    m_skyInclinationSlider->setTickPosition(QSlider::TicksBelow);

    QVBoxLayout *skyGroupLayout = new QVBoxLayout;
    skyGroupLayout->addWidget(labelizeInput(m_skyTimeHint, tr("Time")));
    skyGroupLayout->addWidget(m_skyTimeSlider);
    skyGroupLayout->addWidget(m_skyInclinationSlider);
    skyGroupLayout->addWidget(m_skyAnimation);
    m_skyGroup->setLayout(skyGroupLayout);
}

void Window::skyAnimationStateChanged(int state)
{
    m_glWidget->terrain()->setSkyAnimation(state == Qt::Checked);
}

void Window::terrainShowNormalsStateChanged(int state)
{
    m_glWidget->terrain()->setShowNormals(state == Qt::Checked);
}

void Window::updateTimeHint(int time)
{
    QString timeStr;
    timeStr.sprintf("%02d:%02d", time / 60, time % 60);
    m_skyTimeHint->setText(timeStr);
}

void Window::fillDefault()
{
    m_cameraPosX->setValue(double(Config::cameraPosition().x()));
    m_cameraPosY->setValue(double(Config::cameraPosition().y()));
    m_cameraPosZ->setValue(double(Config::cameraPosition().z()));

    m_cameraRotX->setValue(double(Config::cameraRotation().x()));
    m_cameraRotY->setValue(double(Config::cameraRotation().y()));

    m_terrainShowNormals->setChecked(Config::terrainShowNormals());

    m_skyTimeSlider->setValue(Config::skyTime());
    updateTimeHint(Config::skyTime());
    m_skyInclinationSlider->setValue(Config::skyInclination());
    m_skyAnimation->setChecked(Config::skyAnimation());
}

void Window::connectInputs()
{
    connect(m_cameraPosX, SIGNAL(valueChanged(double)), m_glWidget->terrain()->camera(), SLOT(setX(double)));
    connect(m_cameraPosY, SIGNAL(valueChanged(double)), m_glWidget->terrain()->camera(), SLOT(setY(double)));
    connect(m_cameraPosZ, SIGNAL(valueChanged(double)), m_glWidget->terrain()->camera(), SLOT(setZ(double)));

    connect(m_cameraRotX, SIGNAL(valueChanged(double)), m_glWidget->terrain()->camera(), SLOT(setXAngleDegrees(double)));
    connect(m_cameraRotY, SIGNAL(valueChanged(double)), m_glWidget->terrain()->camera(), SLOT(setYAngleDegrees(double)));

    connect(m_glWidget->terrain()->camera(), SIGNAL(positionChanged(QVector3D)), this, SLOT(updateCameraPosition(QVector3D)));
    connect(m_glWidget->terrain()->camera(), SIGNAL(rotationXChanged(double)), m_cameraRotX, SLOT(setValue(double)));
    connect(m_glWidget->terrain()->camera(), SIGNAL(rotationYChanged(double)), m_cameraRotY, SLOT(setValue(double)));

    connect(m_skyTimeSlider, SIGNAL(valueChanged(int)), this, SLOT(updateTimeHint(int)));
    connect(m_skyTimeSlider, SIGNAL(valueChanged(int)), m_glWidget->terrain()->light(), SLOT(setTimeOfDay(int)));

    connect(m_glWidget->terrain()->light(), SIGNAL(timeOfDayChanged(int)), m_skyTimeSlider, SLOT(setValue(int)));
    connect(m_skyInclinationSlider, SIGNAL(valueChanged(int)), m_glWidget->terrain()->light(), SLOT(setInclination(int)));
    connect(m_skyAnimation, SIGNAL(stateChanged(int)), this, SLOT(skyAnimationStateChanged(int)));

    connect(m_terrainShowNormals, SIGNAL(stateChanged(int)), this, SLOT(terrainShowNormalsStateChanged(int)));
}