path: root/openglscene.cpp

#include "openglscene.h"

#include "model.h"

#include <QtGui>
#include <QtOpenGL>

#ifndef QT_NO_CONCURRENT
#include <QFutureWatcher>
#endif

#ifndef GL_MULTISAMPLE
#define GL_MULTISAMPLE  0x809D
#endif

class Controls : public QWidget
{
    Q_OBJECT

public:
    Controls(OpenGLScene *scene);

private slots:
    void loadModel(const QString &model);
    void modelLoaded();
    void setModelColor(bool showDialog = true);
    void setBackgroundColor(bool showDialog = true);

private:
    OpenGLScene *m_scene;
#ifndef QT_NO_CONCURRENT
    QFutureWatcher<Model *> m_modelLoader;
#endif
    QComboBox *m_models;

    QColor m_modelColor;
    QColor m_backgroundColor;
    QDir m_dir;
};

Controls::Controls(OpenGLScene *scene)
    : m_scene(scene)
    , m_models(new QComboBox)
    , m_modelColor(QColor::fromCmykF(0.40, 0.0, 1.0, 0.0))
    , m_backgroundColor(QColor::fromCmykF(0.39, 0.39, 0.0, 0.0))
    , m_dir(QLatin1String("models"))
{
    QVBoxLayout *layout = new QVBoxLayout(this);

    layout->addWidget(new QLabel(tr("Model:")));

    m_dir.setNameFilters(QStringList() << QLatin1String("*.obj"));
    m_models->addItems(m_dir.entryList());
    connect(m_models, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(loadModel(const QString &)));
#ifndef QT_NO_CONCURRENT
    connect(&m_modelLoader, SIGNAL(finished()), this, SLOT(modelLoaded()));
#endif

    if (m_models->count() > 0)
        loadModel(m_models->currentText());
    layout->addWidget(m_models);

    QCheckBox *wireframe = new QCheckBox(tr("Render as wireframe"));
    wireframe->setChecked(true);
    connect(wireframe, SIGNAL(toggled(bool)), m_scene, SLOT(enableWireframe(bool)));
    layout->addWidget(wireframe);

    QCheckBox *normals = new QCheckBox(tr("Display normals vectors"));
    wireframe->setChecked(false);
    connect(normals, SIGNAL(toggled(bool)), m_scene, SLOT(enableNormals(bool)));
    layout->addWidget(normals);

    layout->addWidget(new QLabel(tr("Light position:")));
    QSlider *lightPosition = new QSlider(Qt::Horizontal);
    lightPosition->setRange(-100, 100);
    connect(lightPosition, SIGNAL(valueChanged(int)), m_scene, SLOT(setLightPosition(int)));
    layout->addWidget(lightPosition);

    m_scene->setLightPosition(lightPosition->value());

    QPushButton *colorButton = new QPushButton(tr("Choose model color"));
    connect(colorButton, SIGNAL(pressed()), this, SLOT(setModelColor()));
    layout->addWidget(colorButton);
    setModelColor(false);

    QPushButton *backgroundButton = new QPushButton(tr("Choose background color"));
    connect(backgroundButton, SIGNAL(pressed()), this, SLOT(setBackgroundColor()));
    layout->addWidget(backgroundButton);
    setBackgroundColor(false);
}

Model *loadModel(const QString &filename)
{
    return new Model(filename);
}

void Controls::loadModel(const QString &filename)
{
    m_models->setEnabled(false);
    QApplication::setOverrideCursor(Qt::BusyCursor);
#ifndef QT_NO_CONCURRENT
    m_modelLoader.setFuture(QtConcurrent::run(::loadModel, m_dir.filePath(filename)));
#else
    m_scene->setModel(::loadModel(m_dir.filePath(filename)));
    modelLoaded();
#endif
}

void Controls::modelLoaded()
{
#ifndef QT_NO_CONCURRENT
    m_scene->setModel(m_modelLoader.result());
#endif
    m_models->setEnabled(true);
    QApplication::restoreOverrideCursor();
}

void Controls::setModelColor(bool showDialog)
{
    if (showDialog)
        m_modelColor = QColorDialog::getColor(m_modelColor);

    m_scene->setModelColor(m_modelColor);
}

void Controls::setBackgroundColor(bool showDialog)
{
    if (showDialog)
        m_backgroundColor = QColorDialog::getColor(m_backgroundColor);

    m_scene->setBackgroundColor(m_backgroundColor);
}

OpenGLScene::OpenGLScene()
    : m_wireframeEnabled(true)
    , m_normalsEnabled(false)
    , m_rotating(false)
    , m_distance(1.4f)
    , m_model(0)
    , m_lastTime(0)
    , m_angularMomentum(0, 40, 0)
{
    Controls *controls = new Controls(this);
    controls->setWindowOpacity(0.8);

    QGraphicsProxyWidget *item = addWidget(controls);
    item->translate(10, 10);
    item->setCacheMode(QGraphicsItem::DeviceCoordinateCache);

    m_time.start();
}

void OpenGLScene::drawBackground(QPainter *painter, const QRectF &)
{
    if (painter->paintEngine()->type() != QPaintEngine::OpenGL) {
        qWarning("OpenGLScene: drawBackground needs a QGLWidget to be set as viewport on the graphics view");
        return;
    }

    glClearColor(m_backgroundColor.redF(), m_backgroundColor.greenF(), m_backgroundColor.blueF(), 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluPerspective(70, painter->device()->width() / float(painter->device()->height()), 0.01, 1000);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    float pos[] = { m_lightPos, 5, 2, 0 };
    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    glColor4f(m_modelColor.redF(), m_modelColor.greenF(), m_modelColor.blueF(), 1.0f);

    if (!m_rotating) {
        const int delta = m_time.elapsed() - m_lastTime;
        m_rotation += m_angularMomentum * (delta / 1000.0);
        m_lastTime += delta;
    }

    glLoadIdentity();
    glTranslatef(0, 0, -m_distance);
    glRotatef(m_rotation.x, 1, 0, 0);
    glRotatef(m_rotation.y, 0, 1, 0);
    glRotatef(m_rotation.z, 0, 0, 1);

    glEnable(GL_MULTISAMPLE);
    if (m_model)
        m_model->render(m_wireframeEnabled, m_normalsEnabled);
    glDisable(GL_MULTISAMPLE);

    glPopMatrix();

    glMatrixMode(GL_PROJECTION);
    glPopMatrix();

    if (!m_rotating)
        QTimer::singleShot(20, this, SLOT(update()));
}

void OpenGLScene::setModel(Model *model)
{
    delete m_model;
    m_model = model;
    update();
}

void OpenGLScene::enableWireframe(bool enabled)
{
    m_wireframeEnabled = enabled;
}

void OpenGLScene::enableNormals(bool enabled)
{
    m_normalsEnabled = enabled;
}

void OpenGLScene::setLightPosition(int pos)
{
    m_lightPos = pos * 0.05;
    update();
}

void OpenGLScene::setModelColor(const QColor &color)
{
    m_modelColor = color;
    update();
}

void OpenGLScene::setBackgroundColor(const QColor &color)
{
    m_backgroundColor = color;
    update();
}

void OpenGLScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    QGraphicsScene::mouseMoveEvent(event);
    if (event->isAccepted() || !m_rotating)
        return;

    const QPointF delta = event->scenePos() - event->lastScenePos();
    const Point3d angularImpulse = Point3d(delta.y(), delta.x(), 0) * 0.1;

    m_rotation += angularImpulse;
    m_angularMomentum += angularImpulse;

    event->accept();
    update();
}

void OpenGLScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    QGraphicsScene::mousePressEvent(event);
    if (event->isAccepted())
        return;

    m_lastTime = m_time.elapsed();
    m_angularMomentum = Point3d();
    m_rotating = true;

    event->accept();
}

void OpenGLScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    QGraphicsScene::mouseReleaseEvent(event);
    if (event->isAccepted())
        return;

    const int delta = m_time.elapsed() - m_lastTime;
    m_angularMomentum *= (1000.0 / qMax(1, delta));
    m_lastTime += delta;
    m_rotating = false;

    event->accept();
    update();
}

void OpenGLScene::wheelEvent(QGraphicsSceneWheelEvent *event)
{
    QGraphicsScene::wheelEvent(event);
    if (event->isAccepted())
        return;

    m_distance *= qPow(1.2, -event->delta() / 120);
    event->accept();
    update();
}

#include "openglscene.moc"