/**************************************************************************** ** ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the demonstration applications of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** GNU Lesser General Public License Usage ** This file may be used under the terms of the GNU Lesser General Public ** License version 2.1 as published by the Free Software Foundation and ** appearing in the file LICENSE.LGPL included in the packaging of this ** file. Please review the following information to ensure the GNU Lesser ** General Public License version 2.1 requirements will be met: ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU General ** Public License version 3.0 as published by the Free Software Foundation ** and appearing in the file LICENSE.GPL included in the packaging of this ** file. Please review the following information to ensure the GNU General ** Public License version 3.0 requirements will be met: ** http://www.gnu.org/copyleft/gpl.html. ** ** Other Usage ** Alternatively, this file may be used in accordance with the terms and ** conditions contained in a signed written agreement between you and Nokia. ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include <QDebug> #include "scene.h" #include <QtGui/qmatrix4x4.h> #include <QtGui/qvector3d.h> #include "3rdparty/fbm.h" void checkGLErrors(const QString& prefix) { switch (glGetError()) { case GL_NO_ERROR: //qDebug() << prefix << tr("No error."); break; case GL_INVALID_ENUM: qDebug() << prefix << QObject::tr("Invalid enum."); break; case GL_INVALID_VALUE: qDebug() << prefix << QObject::tr("Invalid value."); break; case GL_INVALID_OPERATION: qDebug() << prefix << QObject::tr("Invalid operation."); break; case GL_STACK_OVERFLOW: qDebug() << prefix << QObject::tr("Stack overflow."); break; case GL_STACK_UNDERFLOW: qDebug() << prefix << QObject::tr("Stack underflow."); break; case GL_OUT_OF_MEMORY: qDebug() << prefix << QObject::tr("Out of memory."); break; default: qDebug() << prefix << QObject::tr("Unknown error."); break; } } //============================================================================// // ColorEdit // //============================================================================// ColorEdit::ColorEdit(QRgb initialColor, int id) : m_color(initialColor), m_id(id) { QHBoxLayout *layout = new QHBoxLayout; setLayout(layout); layout->setContentsMargins(0, 0, 0, 0); m_lineEdit = new QLineEdit(QString::number(m_color, 16)); layout->addWidget(m_lineEdit); m_button = new QFrame; QPalette palette = m_button->palette(); palette.setColor(QPalette::Window, QColor(m_color)); m_button->setPalette(palette); m_button->setAutoFillBackground(true); m_button->setMinimumSize(32, 0); m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred); m_button->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken); layout->addWidget(m_button); connect(m_lineEdit, SIGNAL(editingFinished()), this, SLOT(editDone())); } void ColorEdit::editDone() { bool ok; QRgb newColor = m_lineEdit->text().toUInt(&ok, 16); if (ok) setColor(newColor); } void ColorEdit::mousePressEvent(QMouseEvent *event) { if (event->button() == Qt::LeftButton) { QColor color(m_color); QColorDialog dialog(color, 0); dialog.setOption(QColorDialog::ShowAlphaChannel, true); // The ifdef block is a workaround for the beta, TODO: remove when bug 238525 is fixed #ifdef Q_WS_MAC dialog.setOption(QColorDialog::DontUseNativeDialog, true); #endif dialog.move(280, 120); if (dialog.exec() == QDialog::Rejected) return; QRgb newColor = dialog.selectedColor().rgba(); if (newColor == m_color) return; setColor(newColor); } } void ColorEdit::setColor(QRgb color) { m_color = color; m_lineEdit->setText(QString::number(m_color, 16)); // "Clean up" text QPalette palette = m_button->palette(); palette.setColor(QPalette::Window, QColor(m_color)); m_button->setPalette(palette); emit colorChanged(m_color, m_id); } //============================================================================// // FloatEdit // //============================================================================// FloatEdit::FloatEdit(float initialValue, int id) : m_value(initialValue), m_id(id) { QHBoxLayout *layout = new QHBoxLayout; setLayout(layout); layout->setContentsMargins(0, 0, 0, 0); m_lineEdit = new QLineEdit(QString::number(m_value)); layout->addWidget(m_lineEdit); connect(m_lineEdit, SIGNAL(editingFinished()), this, SLOT(editDone())); } void FloatEdit::editDone() { bool ok; float newValue = m_lineEdit->text().toFloat(&ok); if (ok) { m_value = newValue; m_lineEdit->setText(QString::number(m_value)); // "Clean up" text emit valueChanged(m_value, m_id); } } //============================================================================// // TwoSidedGraphicsWidget // //============================================================================// TwoSidedGraphicsWidget::TwoSidedGraphicsWidget(QGraphicsScene *scene) : QObject(scene) , m_current(0) , m_angle(0) , m_delta(0) { for (int i = 0; i < 2; ++i) m_proxyWidgets[i] = 0; } void TwoSidedGraphicsWidget::setWidget(int index, QWidget *widget) { if (index < 0 || index >= 2) { qWarning("TwoSidedGraphicsWidget::setWidget: Index out of bounds, index == %d", index); return; } GraphicsWidget *proxy = new GraphicsWidget; proxy->setWidget(widget); if (m_proxyWidgets[index]) delete m_proxyWidgets[index]; m_proxyWidgets[index] = proxy; proxy->setCacheMode(QGraphicsItem::ItemCoordinateCache); proxy->setZValue(1e30); // Make sure the dialog is drawn on top of all other (OpenGL) items if (index != m_current) proxy->setVisible(false); qobject_cast<QGraphicsScene *>(parent())->addItem(proxy); } QWidget *TwoSidedGraphicsWidget::widget(int index) { if (index < 0 || index >= 2) { qWarning("TwoSidedGraphicsWidget::widget: Index out of bounds, index == %d", index); return 0; } return m_proxyWidgets[index]->widget(); } void TwoSidedGraphicsWidget::flip() { m_delta = (m_current == 0 ? 9 : -9); animateFlip(); } void TwoSidedGraphicsWidget::animateFlip() { m_angle += m_delta; if (m_angle == 90) { int old = m_current; m_current ^= 1; m_proxyWidgets[old]->setVisible(false); m_proxyWidgets[m_current]->setVisible(true); m_proxyWidgets[m_current]->setGeometry(m_proxyWidgets[old]->geometry()); } QRectF r = m_proxyWidgets[m_current]->boundingRect(); m_proxyWidgets[m_current]->setTransform(QTransform() .translate(r.width() / 2, r.height() / 2) .rotate(m_angle - 180 * m_current, Qt::YAxis) .translate(-r.width() / 2, -r.height() / 2)); if ((m_current == 0 && m_angle > 0) || (m_current == 1 && m_angle < 180)) QTimer::singleShot(25, this, SLOT(animateFlip())); } QVariant GraphicsWidget::itemChange(GraphicsItemChange change, const QVariant &value) { if (change == ItemPositionChange && scene()) { QRectF rect = boundingRect(); QPointF pos = value.toPointF(); QRectF sceneRect = scene()->sceneRect(); if (pos.x() + rect.left() < sceneRect.left()) pos.setX(sceneRect.left() - rect.left()); else if (pos.x() + rect.right() >= sceneRect.right()) pos.setX(sceneRect.right() - rect.right()); if (pos.y() + rect.top() < sceneRect.top()) pos.setY(sceneRect.top() - rect.top()); else if (pos.y() + rect.bottom() >= sceneRect.bottom()) pos.setY(sceneRect.bottom() - rect.bottom()); return pos; } return QGraphicsProxyWidget::itemChange(change, value); } void GraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent *event) { setCacheMode(QGraphicsItem::NoCache); setCacheMode(QGraphicsItem::ItemCoordinateCache); QGraphicsProxyWidget::resizeEvent(event); } void GraphicsWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { painter->setRenderHint(QPainter::Antialiasing, false); QGraphicsProxyWidget::paint(painter, option, widget); //painter->setRenderHint(QPainter::Antialiasing, true); } //============================================================================// // RenderOptionsDialog // //============================================================================// RenderOptionsDialog::RenderOptionsDialog() : QDialog(0, Qt::CustomizeWindowHint | Qt::WindowTitleHint) { setWindowOpacity(0.75); setWindowTitle(tr("Options (double click to flip)")); QGridLayout *layout = new QGridLayout; setLayout(layout); layout->setColumnStretch(1, 1); int row = 0; QCheckBox *check = new QCheckBox(tr("Dynamic cube map")); check->setCheckState(Qt::Unchecked); // Dynamic cube maps are only enabled when multi-texturing and render to texture are available. check->setEnabled(glActiveTexture && glGenFramebuffersEXT); connect(check, SIGNAL(stateChanged(int)), this, SIGNAL(dynamicCubemapToggled(int))); layout->addWidget(check, 0, 0, 1, 2); ++row; QPalette palette; // Load all .par files // .par files have a simple syntax for specifying user adjustable uniform variables. QSet<QByteArray> uniforms; QList<QString> filter = QStringList("*.par"); QList<QFileInfo> files = QDir(":/res/boxes/").entryInfoList(filter, QDir::Files | QDir::Readable); foreach (QFileInfo fileInfo, files) { QFile file(fileInfo.absoluteFilePath()); if (file.open(QIODevice::ReadOnly)) { while (!file.atEnd()) { QList<QByteArray> tokens = file.readLine().simplified().split(' '); QList<QByteArray>::const_iterator it = tokens.begin(); if (it == tokens.end()) continue; QByteArray type = *it; if (++it == tokens.end()) continue; QByteArray name = *it; bool singleElement = (tokens.size() == 3); // type, name and one value char counter[10] = "000000000"; int counterPos = 8; // position of last digit while (++it != tokens.end()) { m_parameterNames << name; if (!singleElement) { m_parameterNames.back() += "["; m_parameterNames.back() += counter + counterPos; m_parameterNames.back() += "]"; int j = 8; // position of last digit ++counter[j]; while (j > 0 && counter[j] > '9') { counter[j] = '0'; ++counter[--j]; } if (j < counterPos) counterPos = j; } if (type == "color") { layout->addWidget(new QLabel(m_parameterNames.back())); bool ok; ColorEdit *colorEdit = new ColorEdit(it->toUInt(&ok, 16), m_parameterNames.size() - 1); m_parameterEdits << colorEdit; layout->addWidget(colorEdit); connect(colorEdit, SIGNAL(colorChanged(QRgb,int)), this, SLOT(setColorParameter(QRgb,int))); ++row; } else if (type == "float") { layout->addWidget(new QLabel(m_parameterNames.back())); bool ok; FloatEdit *floatEdit = new FloatEdit(it->toFloat(&ok), m_parameterNames.size() - 1); m_parameterEdits << floatEdit; layout->addWidget(floatEdit); connect(floatEdit, SIGNAL(valueChanged(float,int)), this, SLOT(setFloatParameter(float,int))); ++row; } } } file.close(); } } layout->addWidget(new QLabel(tr("Texture:"))); m_textureCombo = new QComboBox; connect(m_textureCombo, SIGNAL(currentIndexChanged(int)), this, SIGNAL(textureChanged(int))); layout->addWidget(m_textureCombo); ++row; layout->addWidget(new QLabel(tr("Shader:"))); m_shaderCombo = new QComboBox; connect(m_shaderCombo, SIGNAL(currentIndexChanged(int)), this, SIGNAL(shaderChanged(int))); layout->addWidget(m_shaderCombo); ++row; layout->setRowStretch(row, 1); } int RenderOptionsDialog::addTexture(const QString &name) { m_textureCombo->addItem(name); return m_textureCombo->count() - 1; } int RenderOptionsDialog::addShader(const QString &name) { m_shaderCombo->addItem(name); return m_shaderCombo->count() - 1; } void RenderOptionsDialog::emitParameterChanged() { foreach (ParameterEdit *edit, m_parameterEdits) edit->emitChange(); } void RenderOptionsDialog::setColorParameter(QRgb color, int id) { emit colorParameterChanged(m_parameterNames[id], color); } void RenderOptionsDialog::setFloatParameter(float value, int id) { emit floatParameterChanged(m_parameterNames[id], value); } void RenderOptionsDialog::mouseDoubleClickEvent(QMouseEvent *event) { if (event->button() == Qt::LeftButton) emit doubleClicked(); } //============================================================================// // ItemDialog // //============================================================================// ItemDialog::ItemDialog() : QDialog(0, Qt::CustomizeWindowHint | Qt::WindowTitleHint) { setWindowTitle(tr("Items (double click to flip)")); setWindowOpacity(0.75); resize(160, 100); QVBoxLayout *layout = new QVBoxLayout; setLayout(layout); QPushButton *button; button = new QPushButton(tr("Add Qt box")); layout->addWidget(button); connect(button, SIGNAL(clicked()), this, SLOT(triggerNewQtBox())); button = new QPushButton(tr("Add circle")); layout->addWidget(button); connect(button, SIGNAL(clicked()), this, SLOT(triggerNewCircleItem())); button = new QPushButton(tr("Add square")); layout->addWidget(button); connect(button, SIGNAL(clicked()), this, SLOT(triggerNewSquareItem())); layout->addStretch(1); } void ItemDialog::triggerNewQtBox() { emit newItemTriggered(QtBoxItem); } void ItemDialog::triggerNewCircleItem() { emit newItemTriggered(CircleItem); } void ItemDialog::triggerNewSquareItem() { emit newItemTriggered(SquareItem); } void ItemDialog::mouseDoubleClickEvent(QMouseEvent *event) { if (event->button() == Qt::LeftButton) emit doubleClicked(); } //============================================================================// // Scene // //============================================================================// const static char environmentShaderText[] = "uniform samplerCube env;" "void main() {" "gl_FragColor = textureCube(env, gl_TexCoord[1].xyz);" "}"; Scene::Scene(int width, int height, int maxTextureSize) : m_distExp(600) , m_frame(0) , m_maxTextureSize(maxTextureSize) , m_currentShader(0) , m_currentTexture(0) , m_dynamicCubemap(false) , m_updateAllCubemaps(true) , m_box(0) , m_vertexShader(0) , m_environmentShader(0) , m_environmentProgram(0) { setSceneRect(0, 0, width, height); m_trackBalls[0] = TrackBall(0.05f, QVector3D(0, 1, 0), TrackBall::Sphere); m_trackBalls[1] = TrackBall(0.005f, QVector3D(0, 0, 1), TrackBall::Sphere); m_trackBalls[2] = TrackBall(0.0f, QVector3D(0, 1, 0), TrackBall::Plane); m_renderOptions = new RenderOptionsDialog; m_renderOptions->move(20, 120); m_renderOptions->resize(m_renderOptions->sizeHint()); connect(m_renderOptions, SIGNAL(dynamicCubemapToggled(int)), this, SLOT(toggleDynamicCubemap(int))); connect(m_renderOptions, SIGNAL(colorParameterChanged(QString,QRgb)), this, SLOT(setColorParameter(QString,QRgb))); connect(m_renderOptions, SIGNAL(floatParameterChanged(QString,float)), this, SLOT(setFloatParameter(QString,float))); connect(m_renderOptions, SIGNAL(textureChanged(int)), this, SLOT(setTexture(int))); connect(m_renderOptions, SIGNAL(shaderChanged(int)), this, SLOT(setShader(int))); m_itemDialog = new ItemDialog; connect(m_itemDialog, SIGNAL(newItemTriggered(ItemDialog::ItemType)), this, SLOT(newItem(ItemDialog::ItemType))); TwoSidedGraphicsWidget *twoSided = new TwoSidedGraphicsWidget(this); twoSided->setWidget(0, m_renderOptions); twoSided->setWidget(1, m_itemDialog); connect(m_renderOptions, SIGNAL(doubleClicked()), twoSided, SLOT(flip())); connect(m_itemDialog, SIGNAL(doubleClicked()), twoSided, SLOT(flip())); addItem(new QtBox(64, width - 64, height - 64)); addItem(new QtBox(64, width - 64, 64)); addItem(new QtBox(64, 64, height - 64)); addItem(new QtBox(64, 64, 64)); initGL(); m_timer = new QTimer(this); m_timer->setInterval(20); connect(m_timer, SIGNAL(timeout()), this, SLOT(update())); m_timer->start(); m_time.start(); } Scene::~Scene() { if (m_box) delete m_box; foreach (GLTexture *texture, m_textures) if (texture) delete texture; if (m_mainCubemap) delete m_mainCubemap; foreach (QGLShaderProgram *program, m_programs) if (program) delete program; if (m_vertexShader) delete m_vertexShader; foreach (QGLShader *shader, m_fragmentShaders) if (shader) delete shader; foreach (GLRenderTargetCube *rt, m_cubemaps) if (rt) delete rt; if (m_environmentShader) delete m_environmentShader; if (m_environmentProgram) delete m_environmentProgram; } void Scene::initGL() { m_box = new GLRoundedBox(0.25f, 1.0f, 10); m_vertexShader = new QGLShader(QGLShader::Vertex); m_vertexShader->compileSourceFile(QLatin1String(":/res/boxes/basic.vsh")); QStringList list; list << ":/res/boxes/cubemap_posx.jpg" << ":/res/boxes/cubemap_negx.jpg" << ":/res/boxes/cubemap_posy.jpg" << ":/res/boxes/cubemap_negy.jpg" << ":/res/boxes/cubemap_posz.jpg" << ":/res/boxes/cubemap_negz.jpg"; m_environment = new GLTextureCube(list, qMin(1024, m_maxTextureSize)); m_environmentShader = new QGLShader(QGLShader::Fragment); m_environmentShader->compileSourceCode(environmentShaderText); m_environmentProgram = new QGLShaderProgram; m_environmentProgram->addShader(m_vertexShader); m_environmentProgram->addShader(m_environmentShader); m_environmentProgram->link(); const int NOISE_SIZE = 128; // for a different size, B and BM in fbm.c must also be changed m_noise = new GLTexture3D(NOISE_SIZE, NOISE_SIZE, NOISE_SIZE); QRgb *data = new QRgb[NOISE_SIZE * NOISE_SIZE * NOISE_SIZE]; memset(data, 0, NOISE_SIZE * NOISE_SIZE * NOISE_SIZE * sizeof(QRgb)); QRgb *p = data; float pos[3]; for (int k = 0; k < NOISE_SIZE; ++k) { pos[2] = k * (0x20 / (float)NOISE_SIZE); for (int j = 0; j < NOISE_SIZE; ++j) { for (int i = 0; i < NOISE_SIZE; ++i) { for (int byte = 0; byte < 4; ++byte) { pos[0] = (i + (byte & 1) * 16) * (0x20 / (float)NOISE_SIZE); pos[1] = (j + (byte & 2) * 8) * (0x20 / (float)NOISE_SIZE); *p |= (int)(128.0f * (noise3(pos) + 1.0f)) << (byte * 8); } ++p; } } } m_noise->load(NOISE_SIZE, NOISE_SIZE, NOISE_SIZE, data); delete[] data; m_mainCubemap = new GLRenderTargetCube(512); QStringList filter; QList<QFileInfo> files; // Load all .png files as textures m_currentTexture = 0; filter = QStringList("*.png"); files = QDir(":/res/boxes/").entryInfoList(filter, QDir::Files | QDir::Readable); foreach (QFileInfo file, files) { GLTexture *texture = new GLTexture2D(file.absoluteFilePath(), qMin(256, m_maxTextureSize), qMin(256, m_maxTextureSize)); if (texture->failed()) { delete texture; continue; } m_textures << texture; m_renderOptions->addTexture(file.baseName()); } if (m_textures.size() == 0) m_textures << new GLTexture2D(qMin(64, m_maxTextureSize), qMin(64, m_maxTextureSize)); // Load all .fsh files as fragment shaders m_currentShader = 0; filter = QStringList("*.fsh"); files = QDir(":/res/boxes/").entryInfoList(filter, QDir::Files | QDir::Readable); foreach (QFileInfo file, files) { QGLShaderProgram *program = new QGLShaderProgram; QGLShader* shader = new QGLShader(QGLShader::Fragment); shader->compileSourceFile(file.absoluteFilePath()); // The program does not take ownership over the shaders, so store them in a vector so they can be deleted afterwards. program->addShader(m_vertexShader); program->addShader(shader); if (!program->link()) { qWarning("Failed to compile and link shader program"); qWarning("Vertex shader log:"); qWarning() << m_vertexShader->log(); qWarning() << "Fragment shader log ( file =" << file.absoluteFilePath() << "):"; qWarning() << shader->log(); qWarning("Shader program log:"); qWarning() << program->log(); delete shader; delete program; continue; } m_fragmentShaders << shader; m_programs << program; m_renderOptions->addShader(file.baseName()); program->bind(); m_cubemaps << ((program->uniformLocation("env") != -1) ? new GLRenderTargetCube(qMin(256, m_maxTextureSize)) : 0); program->release(); } if (m_programs.size() == 0) m_programs << new QGLShaderProgram; m_renderOptions->emitParameterChanged(); } static void loadMatrix(const QMatrix4x4& m) { // static to prevent glLoadMatrixf to fail on certain drivers static GLfloat mat[16]; const qreal *data = m.constData(); for (int index = 0; index < 16; ++index) mat[index] = data[index]; glLoadMatrixf(mat); } static void multMatrix(const QMatrix4x4& m) { // static to prevent glMultMatrixf to fail on certain drivers static GLfloat mat[16]; const qreal *data = m.constData(); for (int index = 0; index < 16; ++index) mat[index] = data[index]; glMultMatrixf(mat); } // If one of the boxes should not be rendered, set excludeBox to its index. // If the main box should not be rendered, set excludeBox to -1. void Scene::renderBoxes(const QMatrix4x4 &view, int excludeBox) { QMatrix4x4 invView = view.inverted(); // If multi-texturing is supported, use three saplers. if (glActiveTexture) { glActiveTexture(GL_TEXTURE0); m_textures[m_currentTexture]->bind(); glActiveTexture(GL_TEXTURE2); m_noise->bind(); glActiveTexture(GL_TEXTURE1); } else { m_textures[m_currentTexture]->bind(); } glDisable(GL_LIGHTING); glDisable(GL_CULL_FACE); QMatrix4x4 viewRotation(view); viewRotation(3, 0) = viewRotation(3, 1) = viewRotation(3, 2) = 0.0f; viewRotation(0, 3) = viewRotation(1, 3) = viewRotation(2, 3) = 0.0f; viewRotation(3, 3) = 1.0f; loadMatrix(viewRotation); glScalef(20.0f, 20.0f, 20.0f); // Don't render the environment if the environment texture can't be set for the correct sampler. if (glActiveTexture) { m_environment->bind(); m_environmentProgram->bind(); m_environmentProgram->setUniformValue("tex", GLint(0)); m_environmentProgram->setUniformValue("env", GLint(1)); m_environmentProgram->setUniformValue("noise", GLint(2)); m_box->draw(); m_environmentProgram->release(); m_environment->unbind(); } loadMatrix(view); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); for (int i = 0; i < m_programs.size(); ++i) { if (i == excludeBox) continue; glPushMatrix(); QMatrix4x4 m; m.rotate(m_trackBalls[1].rotation()); multMatrix(m); glRotatef(360.0f * i / m_programs.size(), 0.0f, 0.0f, 1.0f); glTranslatef(2.0f, 0.0f, 0.0f); glScalef(0.3f, 0.6f, 0.6f); if (glActiveTexture) { if (m_dynamicCubemap && m_cubemaps[i]) m_cubemaps[i]->bind(); else m_environment->bind(); } m_programs[i]->bind(); m_programs[i]->setUniformValue("tex", GLint(0)); m_programs[i]->setUniformValue("env", GLint(1)); m_programs[i]->setUniformValue("noise", GLint(2)); m_programs[i]->setUniformValue("view", view); m_programs[i]->setUniformValue("invView", invView); m_box->draw(); m_programs[i]->release(); if (glActiveTexture) { if (m_dynamicCubemap && m_cubemaps[i]) m_cubemaps[i]->unbind(); else m_environment->unbind(); } glPopMatrix(); } if (-1 != excludeBox) { QMatrix4x4 m; m.rotate(m_trackBalls[0].rotation()); multMatrix(m); if (glActiveTexture) { if (m_dynamicCubemap) m_mainCubemap->bind(); else m_environment->bind(); } m_programs[m_currentShader]->bind(); m_programs[m_currentShader]->setUniformValue("tex", GLint(0)); m_programs[m_currentShader]->setUniformValue("env", GLint(1)); m_programs[m_currentShader]->setUniformValue("noise", GLint(2)); m_programs[m_currentShader]->setUniformValue("view", view); m_programs[m_currentShader]->setUniformValue("invView", invView); m_box->draw(); m_programs[m_currentShader]->release(); if (glActiveTexture) { if (m_dynamicCubemap) m_mainCubemap->unbind(); else m_environment->unbind(); } } if (glActiveTexture) { glActiveTexture(GL_TEXTURE2); m_noise->unbind(); glActiveTexture(GL_TEXTURE0); } m_textures[m_currentTexture]->unbind(); } void Scene::setStates() { //glClearColor(0.25f, 0.25f, 0.5f, 1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); //glEnable(GL_COLOR_MATERIAL); glEnable(GL_TEXTURE_2D); glEnable(GL_NORMALIZE); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); setLights(); float materialSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f}; glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 32.0f); } void Scene::setLights() { glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); //float lightColour[] = {1.0f, 1.0f, 1.0f, 1.0f}; float lightDir[] = {0.0f, 0.0f, 1.0f, 0.0f}; //glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColour); //glLightfv(GL_LIGHT0, GL_SPECULAR, lightColour); glLightfv(GL_LIGHT0, GL_POSITION, lightDir); glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0f); glEnable(GL_LIGHT0); } void Scene::defaultStates() { //glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); //glDisable(GL_COLOR_MATERIAL); glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHT0); glDisable(GL_NORMALIZE); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0f); float defaultMaterialSpecular[] = {0.0f, 0.0f, 0.0f, 1.0f}; glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, defaultMaterialSpecular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f); } void Scene::renderCubemaps() { // To speed things up, only update the cubemaps for the small cubes every N frames. const int N = (m_updateAllCubemaps ? 1 : 3); QMatrix4x4 mat; GLRenderTargetCube::getProjectionMatrix(mat, 0.1f, 100.0f); glMatrixMode(GL_PROJECTION); glPushMatrix(); loadMatrix(mat); glMatrixMode(GL_MODELVIEW); glPushMatrix(); QVector3D center; for (int i = m_frame % N; i < m_cubemaps.size(); i += N) { if (0 == m_cubemaps[i]) continue; float angle = 2.0f * PI * i / m_cubemaps.size(); center = m_trackBalls[1].rotation().rotatedVector(QVector3D(cos(angle), sin(angle), 0.0f)); for (int face = 0; face < 6; ++face) { m_cubemaps[i]->begin(face); GLRenderTargetCube::getViewMatrix(mat, face); QVector4D v = QVector4D(-center.x(), -center.y(), -center.z(), 1.0); mat.setColumn(3, mat * v); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderBoxes(mat, i); m_cubemaps[i]->end(); } } for (int face = 0; face < 6; ++face) { m_mainCubemap->begin(face); GLRenderTargetCube::getViewMatrix(mat, face); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderBoxes(mat, -1); m_mainCubemap->end(); } glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); m_updateAllCubemaps = false; } void Scene::drawBackground(QPainter *painter, const QRectF &) { float width = float(painter->device()->width()); float height = float(painter->device()->height()); painter->beginNativePainting(); setStates(); if (m_dynamicCubemap) renderCubemaps(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); gluPerspective(60.0, width / height, 0.01, 15.0); glMatrixMode(GL_MODELVIEW); QMatrix4x4 view; view.rotate(m_trackBalls[2].rotation()); view(2, 3) -= 2.0f * exp(m_distExp / 1200.0f); renderBoxes(view); defaultStates(); ++m_frame; painter->endNativePainting(); } QPointF Scene::pixelPosToViewPos(const QPointF& p) { return QPointF(2.0 * float(p.x()) / width() - 1.0, 1.0 - 2.0 * float(p.y()) / height()); } void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { QGraphicsScene::mouseMoveEvent(event); if (event->isAccepted()) return; if (event->buttons() & Qt::LeftButton) { m_trackBalls[0].move(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); event->accept(); } else { m_trackBalls[0].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); } if (event->buttons() & Qt::RightButton) { m_trackBalls[1].move(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); event->accept(); } else { m_trackBalls[1].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); } if (event->buttons() & Qt::MidButton) { m_trackBalls[2].move(pixelPosToViewPos(event->scenePos()), QQuaternion()); event->accept(); } else { m_trackBalls[2].release(pixelPosToViewPos(event->scenePos()), QQuaternion()); } } void Scene::mousePressEvent(QGraphicsSceneMouseEvent *event) { QGraphicsScene::mousePressEvent(event); if (event->isAccepted()) return; if (event->buttons() & Qt::LeftButton) { m_trackBalls[0].push(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); event->accept(); } if (event->buttons() & Qt::RightButton) { m_trackBalls[1].push(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); event->accept(); } if (event->buttons() & Qt::MidButton) { m_trackBalls[2].push(pixelPosToViewPos(event->scenePos()), QQuaternion()); event->accept(); } } void Scene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { QGraphicsScene::mouseReleaseEvent(event); if (event->isAccepted()) return; if (event->button() == Qt::LeftButton) { m_trackBalls[0].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); event->accept(); } if (event->button() == Qt::RightButton) { m_trackBalls[1].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate()); event->accept(); } if (event->button() == Qt::MidButton) { m_trackBalls[2].release(pixelPosToViewPos(event->scenePos()), QQuaternion()); event->accept(); } } void Scene::wheelEvent(QGraphicsSceneWheelEvent * event) { QGraphicsScene::wheelEvent(event); if (!event->isAccepted()) { m_distExp += event->delta(); if (m_distExp < -8 * 120) m_distExp = -8 * 120; if (m_distExp > 10 * 120) m_distExp = 10 * 120; event->accept(); } } void Scene::setShader(int index) { if (index >= 0 && index < m_fragmentShaders.size()) m_currentShader = index; } void Scene::setTexture(int index) { if (index >= 0 && index < m_textures.size()) m_currentTexture = index; } void Scene::toggleDynamicCubemap(int state) { if ((m_dynamicCubemap = (state == Qt::Checked))) m_updateAllCubemaps = true; } void Scene::setColorParameter(const QString &name, QRgb color) { // set the color in all programs foreach (QGLShaderProgram *program, m_programs) { program->bind(); program->setUniformValue(program->uniformLocation(name), QColor(color)); program->release(); } } void Scene::setFloatParameter(const QString &name, float value) { // set the color in all programs foreach (QGLShaderProgram *program, m_programs) { program->bind(); program->setUniformValue(program->uniformLocation(name), value); program->release(); } } void Scene::newItem(ItemDialog::ItemType type) { QSize size = sceneRect().size().toSize(); switch (type) { case ItemDialog::QtBoxItem: addItem(new QtBox(64, rand() % (size.width() - 64) + 32, rand() % (size.height() - 64) + 32)); break; case ItemDialog::CircleItem: addItem(new CircleItem(64, rand() % (size.width() - 64) + 32, rand() % (size.height() - 64) + 32)); break; case ItemDialog::SquareItem: addItem(new SquareItem(64, rand() % (size.width() - 64) + 32, rand() % (size.height() - 64) + 32)); break; default: break; } }
© 2008-2011 Nokia Corporation and/or its subsidiaries. Nokia, Qt and their respective logos are trademarks of Nokia Corporation in Finland and/or other countries worldwide.
All other trademarks are property of their respective owners. Privacy Policy
Licensees holding valid Qt Commercial licenses may use this document in accordance with the Qt Commercial License Agreement provided with the Software or, alternatively, in accordance with the terms contained in a written agreement between you and Nokia.
Alternatively, this document may be used under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation.