Update copyright headers
[qt:qt.git] / demos / boxes / scene.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the demonstration applications of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file.  Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include <QDebug>
43 #include "scene.h"
44 #include <QtGui/qmatrix4x4.h>
45 #include <QtGui/qvector3d.h>
46
47 #include "3rdparty/fbm.h"
48
49 void checkGLErrors(const QString& prefix)
50 {
51     switch (glGetError()) {
52     case GL_NO_ERROR:
53         //qDebug() << prefix << tr("No error.");
54         break;
55     case GL_INVALID_ENUM:
56         qDebug() << prefix << QObject::tr("Invalid enum.");
57         break;
58     case GL_INVALID_VALUE:
59         qDebug() << prefix << QObject::tr("Invalid value.");
60         break;
61     case GL_INVALID_OPERATION:
62         qDebug() << prefix << QObject::tr("Invalid operation.");
63         break;
64     case GL_STACK_OVERFLOW:
65         qDebug() << prefix << QObject::tr("Stack overflow.");
66         break;
67     case GL_STACK_UNDERFLOW:
68         qDebug() << prefix << QObject::tr("Stack underflow.");
69         break;
70     case GL_OUT_OF_MEMORY:
71         qDebug() << prefix << QObject::tr("Out of memory.");
72         break;
73     default:
74         qDebug() << prefix << QObject::tr("Unknown error.");
75         break;
76     }
77 }
78
79 //============================================================================//
80 //                                  ColorEdit                                 //
81 //============================================================================//
82
83 ColorEdit::ColorEdit(QRgb initialColor, int id)
84     : m_color(initialColor), m_id(id)
85 {
86     QHBoxLayout *layout = new QHBoxLayout;
87     setLayout(layout);
88     layout->setContentsMargins(0, 0, 0, 0);
89
90     m_lineEdit = new QLineEdit(QString::number(m_color, 16));
91     layout->addWidget(m_lineEdit);
92
93     m_button = new QFrame;
94     QPalette palette = m_button->palette();
95     palette.setColor(QPalette::Window, QColor(m_color));
96     m_button->setPalette(palette);
97     m_button->setAutoFillBackground(true);
98     m_button->setMinimumSize(32, 0);
99     m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
100     m_button->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
101     layout->addWidget(m_button);
102
103     connect(m_lineEdit, SIGNAL(editingFinished()), this, SLOT(editDone()));
104 }
105
106 void ColorEdit::editDone()
107 {
108     bool ok;
109     QRgb newColor = m_lineEdit->text().toUInt(&ok, 16);
110     if (ok)
111         setColor(newColor);
112 }
113
114 void ColorEdit::mousePressEvent(QMouseEvent *event)
115 {
116     if (event->button() == Qt::LeftButton) {
117         QColor color(m_color);
118         QColorDialog dialog(color, 0);
119         dialog.setOption(QColorDialog::ShowAlphaChannel, true);
120 // The ifdef block is a workaround for the beta, TODO: remove when bug 238525 is fixed
121 #ifdef Q_WS_MAC
122         dialog.setOption(QColorDialog::DontUseNativeDialog, true);
123 #endif
124         dialog.move(280, 120);
125         if (dialog.exec() == QDialog::Rejected)
126             return;
127         QRgb newColor = dialog.selectedColor().rgba();
128         if (newColor == m_color)
129             return;
130         setColor(newColor);
131     }
132 }
133
134 void ColorEdit::setColor(QRgb color)
135 {
136     m_color = color;
137     m_lineEdit->setText(QString::number(m_color, 16)); // "Clean up" text
138     QPalette palette = m_button->palette();
139     palette.setColor(QPalette::Window, QColor(m_color));
140     m_button->setPalette(palette);
141     emit colorChanged(m_color, m_id);
142 }
143
144 //============================================================================//
145 //                                  FloatEdit                                 //
146 //============================================================================//
147
148 FloatEdit::FloatEdit(float initialValue, int id)
149     : m_value(initialValue), m_id(id)
150 {
151     QHBoxLayout *layout = new QHBoxLayout;
152     setLayout(layout);
153     layout->setContentsMargins(0, 0, 0, 0);
154
155     m_lineEdit = new QLineEdit(QString::number(m_value));
156     layout->addWidget(m_lineEdit);
157
158     connect(m_lineEdit, SIGNAL(editingFinished()), this, SLOT(editDone()));
159 }
160
161 void FloatEdit::editDone()
162 {
163     bool ok;
164     float newValue = m_lineEdit->text().toFloat(&ok);
165     if (ok) {
166         m_value = newValue;
167         m_lineEdit->setText(QString::number(m_value)); // "Clean up" text
168         emit valueChanged(m_value, m_id);
169     }
170 }
171
172 //============================================================================//
173 //                           TwoSidedGraphicsWidget                           //
174 //============================================================================//
175
176 TwoSidedGraphicsWidget::TwoSidedGraphicsWidget(QGraphicsScene *scene)
177     : QObject(scene)
178     , m_current(0)
179     , m_angle(0)
180     , m_delta(0)
181 {
182     for (int i = 0; i < 2; ++i)
183         m_proxyWidgets[i] = 0;
184 }
185
186 void TwoSidedGraphicsWidget::setWidget(int index, QWidget *widget)
187 {
188     if (index < 0 || index >= 2)
189         {
190                 qWarning("TwoSidedGraphicsWidget::setWidget: Index out of bounds, index == %d", index);
191                 return;
192         }
193
194     GraphicsWidget *proxy = new GraphicsWidget;
195     proxy->setWidget(widget);
196
197     if (m_proxyWidgets[index])
198         delete m_proxyWidgets[index];
199     m_proxyWidgets[index] = proxy;
200
201     proxy->setCacheMode(QGraphicsItem::ItemCoordinateCache);
202     proxy->setZValue(1e30); // Make sure the dialog is drawn on top of all other (OpenGL) items
203
204     if (index != m_current)
205         proxy->setVisible(false);
206
207     qobject_cast<QGraphicsScene *>(parent())->addItem(proxy);
208 }
209
210 QWidget *TwoSidedGraphicsWidget::widget(int index)
211 {
212     if (index < 0 || index >= 2)
213         {
214                 qWarning("TwoSidedGraphicsWidget::widget: Index out of bounds, index == %d", index);
215                 return 0;
216         }
217     return m_proxyWidgets[index]->widget();
218 }
219
220 void TwoSidedGraphicsWidget::flip()
221 {
222     m_delta = (m_current == 0 ? 9 : -9);
223     animateFlip();
224 }
225
226 void TwoSidedGraphicsWidget::animateFlip()
227 {
228     m_angle += m_delta;
229     if (m_angle == 90) {
230         int old = m_current;
231         m_current ^= 1;
232         m_proxyWidgets[old]->setVisible(false);
233         m_proxyWidgets[m_current]->setVisible(true);
234         m_proxyWidgets[m_current]->setGeometry(m_proxyWidgets[old]->geometry());
235     }
236
237     QRectF r = m_proxyWidgets[m_current]->boundingRect();
238     m_proxyWidgets[m_current]->setTransform(QTransform()
239         .translate(r.width() / 2, r.height() / 2)
240         .rotate(m_angle - 180 * m_current, Qt::YAxis)
241         .translate(-r.width() / 2, -r.height() / 2));
242
243     if ((m_current == 0 && m_angle > 0) || (m_current == 1 && m_angle < 180))
244         QTimer::singleShot(25, this, SLOT(animateFlip()));
245 }
246
247 QVariant GraphicsWidget::itemChange(GraphicsItemChange change, const QVariant &value)
248 {
249     if (change == ItemPositionChange && scene()) {
250         QRectF rect = boundingRect();
251         QPointF pos = value.toPointF();
252         QRectF sceneRect = scene()->sceneRect();
253         if (pos.x() + rect.left() < sceneRect.left())
254             pos.setX(sceneRect.left() - rect.left());
255         else if (pos.x() + rect.right() >= sceneRect.right())
256             pos.setX(sceneRect.right() - rect.right());
257         if (pos.y() + rect.top() < sceneRect.top())
258             pos.setY(sceneRect.top() - rect.top());
259         else if (pos.y() + rect.bottom() >= sceneRect.bottom())
260             pos.setY(sceneRect.bottom() - rect.bottom());
261         return pos;
262     }
263     return QGraphicsProxyWidget::itemChange(change, value);
264 }
265
266 void GraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent *event)
267 {
268     setCacheMode(QGraphicsItem::NoCache);
269     setCacheMode(QGraphicsItem::ItemCoordinateCache);
270     QGraphicsProxyWidget::resizeEvent(event);
271 }
272
273 void GraphicsWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
274 {
275     painter->setRenderHint(QPainter::Antialiasing, false);
276     QGraphicsProxyWidget::paint(painter, option, widget);
277     //painter->setRenderHint(QPainter::Antialiasing, true);
278 }
279
280 //============================================================================//
281 //                             RenderOptionsDialog                            //
282 //============================================================================//
283
284 RenderOptionsDialog::RenderOptionsDialog()
285     : QDialog(0, Qt::CustomizeWindowHint | Qt::WindowTitleHint)
286 {
287     setWindowOpacity(0.75);
288     setWindowTitle(tr("Options (double click to flip)"));
289     QGridLayout *layout = new QGridLayout;
290     setLayout(layout);
291     layout->setColumnStretch(1, 1);
292
293     int row = 0;
294
295     QCheckBox *check = new QCheckBox(tr("Dynamic cube map"));
296     check->setCheckState(Qt::Unchecked);
297     // Dynamic cube maps are only enabled when multi-texturing and render to texture are available.
298     check->setEnabled(glActiveTexture && glGenFramebuffersEXT);
299     connect(check, SIGNAL(stateChanged(int)), this, SIGNAL(dynamicCubemapToggled(int)));
300     layout->addWidget(check, 0, 0, 1, 2);
301     ++row;
302
303     QPalette palette;
304
305     // Load all .par files
306     // .par files have a simple syntax for specifying user adjustable uniform variables.
307     QSet<QByteArray> uniforms;
308     QList<QString> filter = QStringList("*.par");
309     QList<QFileInfo> files = QDir(":/res/boxes/").entryInfoList(filter, QDir::Files | QDir::Readable);
310
311     foreach (QFileInfo fileInfo, files) {
312         QFile file(fileInfo.absoluteFilePath());
313         if (file.open(QIODevice::ReadOnly)) {
314             while (!file.atEnd()) {
315                 QList<QByteArray> tokens = file.readLine().simplified().split(' ');
316                 QList<QByteArray>::const_iterator it = tokens.begin();
317                 if (it == tokens.end())
318                     continue;
319                 QByteArray type = *it;
320                 if (++it == tokens.end())
321                     continue;
322                 QByteArray name = *it;
323                 bool singleElement = (tokens.size() == 3); // type, name and one value
324                 char counter[10] = "000000000";
325                 int counterPos = 8; // position of last digit
326                 while (++it != tokens.end()) {
327                     m_parameterNames << name;
328                     if (!singleElement) {
329                         m_parameterNames.back() += "[";
330                         m_parameterNames.back() += counter + counterPos;
331                         m_parameterNames.back() += "]";
332                         int j = 8; // position of last digit
333                         ++counter[j];
334                         while (j > 0 && counter[j] > '9') {
335                             counter[j] = '0';
336                             ++counter[--j];
337                         }
338                         if (j < counterPos)
339                             counterPos = j;
340                     }
341
342                     if (type == "color") {
343                         layout->addWidget(new QLabel(m_parameterNames.back()));
344                         bool ok;
345                         ColorEdit *colorEdit = new ColorEdit(it->toUInt(&ok, 16), m_parameterNames.size() - 1);
346                         m_parameterEdits << colorEdit;
347                         layout->addWidget(colorEdit);
348                         connect(colorEdit, SIGNAL(colorChanged(QRgb,int)), this, SLOT(setColorParameter(QRgb,int)));
349                         ++row;
350                     } else if (type == "float") {
351                         layout->addWidget(new QLabel(m_parameterNames.back()));
352                         bool ok;
353                         FloatEdit *floatEdit = new FloatEdit(it->toFloat(&ok), m_parameterNames.size() - 1);
354                         m_parameterEdits << floatEdit;
355                         layout->addWidget(floatEdit);
356                         connect(floatEdit, SIGNAL(valueChanged(float,int)), this, SLOT(setFloatParameter(float,int)));
357                         ++row;
358                     }
359                 }
360             }
361             file.close();
362         }
363     }
364
365     layout->addWidget(new QLabel(tr("Texture:")));
366     m_textureCombo = new QComboBox;
367     connect(m_textureCombo, SIGNAL(currentIndexChanged(int)), this, SIGNAL(textureChanged(int)));
368     layout->addWidget(m_textureCombo);
369     ++row;
370
371     layout->addWidget(new QLabel(tr("Shader:")));
372     m_shaderCombo = new QComboBox;
373     connect(m_shaderCombo, SIGNAL(currentIndexChanged(int)), this, SIGNAL(shaderChanged(int)));
374     layout->addWidget(m_shaderCombo);
375     ++row;
376
377     layout->setRowStretch(row, 1);
378 }
379
380 int RenderOptionsDialog::addTexture(const QString &name)
381 {
382     m_textureCombo->addItem(name);
383     return m_textureCombo->count() - 1;
384 }
385
386 int RenderOptionsDialog::addShader(const QString &name)
387 {
388     m_shaderCombo->addItem(name);
389     return m_shaderCombo->count() - 1;
390 }
391
392 void RenderOptionsDialog::emitParameterChanged()
393 {
394     foreach (ParameterEdit *edit, m_parameterEdits)
395         edit->emitChange();
396 }
397
398 void RenderOptionsDialog::setColorParameter(QRgb color, int id)
399 {
400     emit colorParameterChanged(m_parameterNames[id], color);
401 }
402
403 void RenderOptionsDialog::setFloatParameter(float value, int id)
404 {
405     emit floatParameterChanged(m_parameterNames[id], value);
406 }
407
408 void RenderOptionsDialog::mouseDoubleClickEvent(QMouseEvent *event)
409 {
410     if (event->button() == Qt::LeftButton)
411         emit doubleClicked();
412 }
413
414 //============================================================================//
415 //                                 ItemDialog                                 //
416 //============================================================================//
417
418 ItemDialog::ItemDialog()
419     : QDialog(0, Qt::CustomizeWindowHint | Qt::WindowTitleHint)
420 {
421     setWindowTitle(tr("Items (double click to flip)"));
422     setWindowOpacity(0.75);
423     resize(160, 100);
424
425     QVBoxLayout *layout = new QVBoxLayout;
426     setLayout(layout);
427     QPushButton *button;
428
429     button = new QPushButton(tr("Add Qt box"));
430     layout->addWidget(button);
431     connect(button, SIGNAL(clicked()), this, SLOT(triggerNewQtBox()));
432
433     button = new QPushButton(tr("Add circle"));
434     layout->addWidget(button);
435     connect(button, SIGNAL(clicked()), this, SLOT(triggerNewCircleItem()));
436
437     button = new QPushButton(tr("Add square"));
438     layout->addWidget(button);
439     connect(button, SIGNAL(clicked()), this, SLOT(triggerNewSquareItem()));
440
441     layout->addStretch(1);
442 }
443
444 void ItemDialog::triggerNewQtBox()
445 {
446     emit newItemTriggered(QtBoxItem);
447 }
448
449 void ItemDialog::triggerNewCircleItem()
450 {
451     emit newItemTriggered(CircleItem);
452 }
453
454 void ItemDialog::triggerNewSquareItem()
455 {
456     emit newItemTriggered(SquareItem);
457 }
458
459 void ItemDialog::mouseDoubleClickEvent(QMouseEvent *event)
460 {
461     if (event->button() == Qt::LeftButton)
462         emit doubleClicked();
463 }
464
465 //============================================================================//
466 //                                    Scene                                   //
467 //============================================================================//
468
469 const static char environmentShaderText[] =
470     "uniform samplerCube env;"
471     "void main() {"
472         "gl_FragColor = textureCube(env, gl_TexCoord[1].xyz);"
473     "}";
474
475 Scene::Scene(int width, int height, int maxTextureSize)
476     : m_distExp(600)
477     , m_frame(0)
478     , m_maxTextureSize(maxTextureSize)
479     , m_currentShader(0)
480     , m_currentTexture(0)
481     , m_dynamicCubemap(false)
482     , m_updateAllCubemaps(true)
483     , m_box(0)
484     , m_vertexShader(0)
485     , m_environmentShader(0)
486     , m_environmentProgram(0)
487 {
488     setSceneRect(0, 0, width, height);
489
490     m_trackBalls[0] = TrackBall(0.05f, QVector3D(0, 1, 0), TrackBall::Sphere);
491     m_trackBalls[1] = TrackBall(0.005f, QVector3D(0, 0, 1), TrackBall::Sphere);
492     m_trackBalls[2] = TrackBall(0.0f, QVector3D(0, 1, 0), TrackBall::Plane);
493
494     m_renderOptions = new RenderOptionsDialog;
495     m_renderOptions->move(20, 120);
496     m_renderOptions->resize(m_renderOptions->sizeHint());
497
498     connect(m_renderOptions, SIGNAL(dynamicCubemapToggled(int)), this, SLOT(toggleDynamicCubemap(int)));
499     connect(m_renderOptions, SIGNAL(colorParameterChanged(QString,QRgb)), this, SLOT(setColorParameter(QString,QRgb)));
500     connect(m_renderOptions, SIGNAL(floatParameterChanged(QString,float)), this, SLOT(setFloatParameter(QString,float)));
501     connect(m_renderOptions, SIGNAL(textureChanged(int)), this, SLOT(setTexture(int)));
502     connect(m_renderOptions, SIGNAL(shaderChanged(int)), this, SLOT(setShader(int)));
503
504     m_itemDialog = new ItemDialog;
505     connect(m_itemDialog, SIGNAL(newItemTriggered(ItemDialog::ItemType)), this, SLOT(newItem(ItemDialog::ItemType)));
506
507     TwoSidedGraphicsWidget *twoSided = new TwoSidedGraphicsWidget(this);
508     twoSided->setWidget(0, m_renderOptions);
509     twoSided->setWidget(1, m_itemDialog);
510
511     connect(m_renderOptions, SIGNAL(doubleClicked()), twoSided, SLOT(flip()));
512     connect(m_itemDialog, SIGNAL(doubleClicked()), twoSided, SLOT(flip()));
513
514     addItem(new QtBox(64, width - 64, height - 64));
515     addItem(new QtBox(64, width - 64, 64));
516     addItem(new QtBox(64, 64, height - 64));
517     addItem(new QtBox(64, 64, 64));
518
519     initGL();
520
521     m_timer = new QTimer(this);
522     m_timer->setInterval(20);
523     connect(m_timer, SIGNAL(timeout()), this, SLOT(update()));
524     m_timer->start();
525
526     m_time.start();
527 }
528
529 Scene::~Scene()
530 {
531     if (m_box)
532         delete m_box;
533     foreach (GLTexture *texture, m_textures)
534         if (texture) delete texture;
535     if (m_mainCubemap)
536         delete m_mainCubemap;
537     foreach (QGLShaderProgram *program, m_programs)
538         if (program) delete program;
539     if (m_vertexShader)
540         delete m_vertexShader;
541     foreach (QGLShader *shader, m_fragmentShaders)
542         if (shader) delete shader;
543     foreach (GLRenderTargetCube *rt, m_cubemaps)
544         if (rt) delete rt;
545     if (m_environmentShader)
546         delete m_environmentShader;
547     if (m_environmentProgram)
548         delete m_environmentProgram;
549 }
550
551 void Scene::initGL()
552 {
553     m_box = new GLRoundedBox(0.25f, 1.0f, 10);
554
555     m_vertexShader = new QGLShader(QGLShader::Vertex);
556     m_vertexShader->compileSourceFile(QLatin1String(":/res/boxes/basic.vsh"));
557
558     QStringList list;
559     list << ":/res/boxes/cubemap_posx.jpg" << ":/res/boxes/cubemap_negx.jpg" << ":/res/boxes/cubemap_posy.jpg"
560          << ":/res/boxes/cubemap_negy.jpg" << ":/res/boxes/cubemap_posz.jpg" << ":/res/boxes/cubemap_negz.jpg";
561     m_environment = new GLTextureCube(list, qMin(1024, m_maxTextureSize));
562     m_environmentShader = new QGLShader(QGLShader::Fragment);
563     m_environmentShader->compileSourceCode(environmentShaderText);
564     m_environmentProgram = new QGLShaderProgram;
565     m_environmentProgram->addShader(m_vertexShader);
566     m_environmentProgram->addShader(m_environmentShader);
567     m_environmentProgram->link();
568
569     const int NOISE_SIZE = 128; // for a different size, B and BM in fbm.c must also be changed
570     m_noise = new GLTexture3D(NOISE_SIZE, NOISE_SIZE, NOISE_SIZE); 
571     QRgb *data = new QRgb[NOISE_SIZE * NOISE_SIZE * NOISE_SIZE];
572     memset(data, 0, NOISE_SIZE * NOISE_SIZE * NOISE_SIZE * sizeof(QRgb));
573     QRgb *p = data;
574     float pos[3];
575     for (int k = 0; k < NOISE_SIZE; ++k) {
576         pos[2] = k * (0x20 / (float)NOISE_SIZE);
577         for (int j = 0; j < NOISE_SIZE; ++j) {
578             for (int i = 0; i < NOISE_SIZE; ++i) {
579                 for (int byte = 0; byte < 4; ++byte) {
580                     pos[0] = (i + (byte & 1) * 16) * (0x20 / (float)NOISE_SIZE);
581                     pos[1] = (j + (byte & 2) * 8) * (0x20 / (float)NOISE_SIZE);
582                     *p |= (int)(128.0f * (noise3(pos) + 1.0f)) << (byte * 8);
583                 }
584                 ++p;
585             }
586         }
587     }
588     m_noise->load(NOISE_SIZE, NOISE_SIZE, NOISE_SIZE, data);
589     delete[] data;
590
591     m_mainCubemap = new GLRenderTargetCube(512);
592
593     QStringList filter;
594     QList<QFileInfo> files;
595
596     // Load all .png files as textures
597     m_currentTexture = 0;
598     filter = QStringList("*.png");
599     files = QDir(":/res/boxes/").entryInfoList(filter, QDir::Files | QDir::Readable);
600
601     foreach (QFileInfo file, files) {
602         GLTexture *texture = new GLTexture2D(file.absoluteFilePath(), qMin(256, m_maxTextureSize), qMin(256, m_maxTextureSize));
603         if (texture->failed()) {
604             delete texture;
605             continue;
606         }
607         m_textures << texture;
608         m_renderOptions->addTexture(file.baseName());
609     }
610
611     if (m_textures.size() == 0)
612         m_textures << new GLTexture2D(qMin(64, m_maxTextureSize), qMin(64, m_maxTextureSize));
613
614     // Load all .fsh files as fragment shaders
615     m_currentShader = 0;
616     filter = QStringList("*.fsh");
617     files = QDir(":/res/boxes/").entryInfoList(filter, QDir::Files | QDir::Readable);
618     foreach (QFileInfo file, files) {
619         QGLShaderProgram *program = new QGLShaderProgram;
620         QGLShader* shader = new QGLShader(QGLShader::Fragment);
621         shader->compileSourceFile(file.absoluteFilePath());
622         // The program does not take ownership over the shaders, so store them in a vector so they can be deleted afterwards.
623         program->addShader(m_vertexShader);
624         program->addShader(shader);
625         if (!program->link()) {
626             qWarning("Failed to compile and link shader program");
627             qWarning("Vertex shader log:");
628             qWarning() << m_vertexShader->log();
629             qWarning() << "Fragment shader log ( file =" << file.absoluteFilePath() << "):";
630             qWarning() << shader->log();
631             qWarning("Shader program log:");
632             qWarning() << program->log();
633
634             delete shader;
635             delete program;
636             continue;
637         }
638
639         m_fragmentShaders << shader;
640         m_programs << program;
641         m_renderOptions->addShader(file.baseName());
642
643         program->bind();
644         m_cubemaps << ((program->uniformLocation("env") != -1) ? new GLRenderTargetCube(qMin(256, m_maxTextureSize)) : 0);
645         program->release();
646     }
647
648     if (m_programs.size() == 0)
649         m_programs << new QGLShaderProgram;
650
651     m_renderOptions->emitParameterChanged();
652 }
653
654 static void loadMatrix(const QMatrix4x4& m)
655 {
656     // static to prevent glLoadMatrixf to fail on certain drivers
657     static GLfloat mat[16];
658     const qreal *data = m.constData();
659     for (int index = 0; index < 16; ++index)
660         mat[index] = data[index];
661     glLoadMatrixf(mat);
662 }
663
664 static void multMatrix(const QMatrix4x4& m)
665 {
666     // static to prevent glMultMatrixf to fail on certain drivers
667     static GLfloat mat[16];
668     const qreal *data = m.constData();
669     for (int index = 0; index < 16; ++index)
670         mat[index] = data[index];
671     glMultMatrixf(mat);
672 }
673
674 // If one of the boxes should not be rendered, set excludeBox to its index.
675 // If the main box should not be rendered, set excludeBox to -1.
676 void Scene::renderBoxes(const QMatrix4x4 &view, int excludeBox)
677 {
678     QMatrix4x4 invView = view.inverted();
679
680     // If multi-texturing is supported, use three saplers.
681     if (glActiveTexture) {
682         glActiveTexture(GL_TEXTURE0);
683         m_textures[m_currentTexture]->bind();
684         glActiveTexture(GL_TEXTURE2);
685         m_noise->bind();
686         glActiveTexture(GL_TEXTURE1);
687     } else {
688         m_textures[m_currentTexture]->bind();
689     }
690
691     glDisable(GL_LIGHTING);
692     glDisable(GL_CULL_FACE);
693
694     QMatrix4x4 viewRotation(view);
695     viewRotation(3, 0) = viewRotation(3, 1) = viewRotation(3, 2) = 0.0f;
696     viewRotation(0, 3) = viewRotation(1, 3) = viewRotation(2, 3) = 0.0f;
697     viewRotation(3, 3) = 1.0f;
698     loadMatrix(viewRotation);
699     glScalef(20.0f, 20.0f, 20.0f);
700
701     // Don't render the environment if the environment texture can't be set for the correct sampler.
702     if (glActiveTexture) {
703         m_environment->bind();
704         m_environmentProgram->bind();
705         m_environmentProgram->setUniformValue("tex", GLint(0));
706         m_environmentProgram->setUniformValue("env", GLint(1));
707         m_environmentProgram->setUniformValue("noise", GLint(2));
708         m_box->draw();
709         m_environmentProgram->release();
710         m_environment->unbind();
711     }
712
713     loadMatrix(view);
714
715     glEnable(GL_CULL_FACE);
716     glEnable(GL_LIGHTING);
717
718     for (int i = 0; i < m_programs.size(); ++i) {
719         if (i == excludeBox)
720             continue;
721
722         glPushMatrix();
723         QMatrix4x4 m;
724         m.rotate(m_trackBalls[1].rotation());
725         multMatrix(m);
726
727         glRotatef(360.0f * i / m_programs.size(), 0.0f, 0.0f, 1.0f);
728         glTranslatef(2.0f, 0.0f, 0.0f);
729         glScalef(0.3f, 0.6f, 0.6f);
730
731         if (glActiveTexture) {
732             if (m_dynamicCubemap && m_cubemaps[i])
733                 m_cubemaps[i]->bind();
734             else
735                 m_environment->bind();
736         }
737         m_programs[i]->bind();
738         m_programs[i]->setUniformValue("tex", GLint(0));
739         m_programs[i]->setUniformValue("env", GLint(1));
740         m_programs[i]->setUniformValue("noise", GLint(2));
741         m_programs[i]->setUniformValue("view", view);
742         m_programs[i]->setUniformValue("invView", invView);
743         m_box->draw();
744         m_programs[i]->release();
745
746         if (glActiveTexture) {
747             if (m_dynamicCubemap && m_cubemaps[i])
748                 m_cubemaps[i]->unbind();
749             else
750                 m_environment->unbind();
751         }
752         glPopMatrix();
753     }
754
755     if (-1 != excludeBox) {
756         QMatrix4x4 m;
757         m.rotate(m_trackBalls[0].rotation());
758         multMatrix(m);
759
760         if (glActiveTexture) {
761             if (m_dynamicCubemap)
762                 m_mainCubemap->bind();
763             else
764                 m_environment->bind();
765         }
766
767         m_programs[m_currentShader]->bind();
768         m_programs[m_currentShader]->setUniformValue("tex", GLint(0));
769         m_programs[m_currentShader]->setUniformValue("env", GLint(1));
770         m_programs[m_currentShader]->setUniformValue("noise", GLint(2));
771         m_programs[m_currentShader]->setUniformValue("view", view);
772         m_programs[m_currentShader]->setUniformValue("invView", invView);
773         m_box->draw();
774         m_programs[m_currentShader]->release();
775
776         if (glActiveTexture) {
777             if (m_dynamicCubemap)
778                 m_mainCubemap->unbind();
779             else
780                 m_environment->unbind();
781         }
782     }
783
784     if (glActiveTexture) {
785         glActiveTexture(GL_TEXTURE2);
786         m_noise->unbind();
787         glActiveTexture(GL_TEXTURE0);
788     }
789     m_textures[m_currentTexture]->unbind();
790 }
791
792 void Scene::setStates()
793 {
794     //glClearColor(0.25f, 0.25f, 0.5f, 1.0f);
795
796     glEnable(GL_DEPTH_TEST);
797     glEnable(GL_CULL_FACE);
798     glEnable(GL_LIGHTING);
799     //glEnable(GL_COLOR_MATERIAL);
800     glEnable(GL_TEXTURE_2D);
801     glEnable(GL_NORMALIZE);
802
803     glMatrixMode(GL_PROJECTION);
804     glPushMatrix();
805     glLoadIdentity();
806
807     glMatrixMode(GL_MODELVIEW);
808     glPushMatrix();
809     glLoadIdentity();
810
811     setLights();
812
813     float materialSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f};
814     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular);
815     glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 32.0f);
816 }
817
818 void Scene::setLights()
819 {
820     glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
821     //float lightColour[] = {1.0f, 1.0f, 1.0f, 1.0f};
822     float lightDir[] = {0.0f, 0.0f, 1.0f, 0.0f};
823     //glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColour);
824     //glLightfv(GL_LIGHT0, GL_SPECULAR, lightColour);
825     glLightfv(GL_LIGHT0, GL_POSITION, lightDir);
826     glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0f);
827     glEnable(GL_LIGHT0);
828 }
829
830 void Scene::defaultStates()
831 {
832     //glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
833
834     glDisable(GL_DEPTH_TEST);
835     glDisable(GL_CULL_FACE);
836     glDisable(GL_LIGHTING);
837     //glDisable(GL_COLOR_MATERIAL);
838     glDisable(GL_TEXTURE_2D);
839     glDisable(GL_LIGHT0);
840     glDisable(GL_NORMALIZE);
841
842     glMatrixMode(GL_MODELVIEW);
843     glPopMatrix();
844
845     glMatrixMode(GL_PROJECTION);
846     glPopMatrix();
847
848     glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0f);
849     float defaultMaterialSpecular[] = {0.0f, 0.0f, 0.0f, 1.0f};
850     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, defaultMaterialSpecular);
851     glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f);
852 }
853
854 void Scene::renderCubemaps()
855 {
856     // To speed things up, only update the cubemaps for the small cubes every N frames.
857     const int N = (m_updateAllCubemaps ? 1 : 3);
858
859     QMatrix4x4 mat;
860     GLRenderTargetCube::getProjectionMatrix(mat, 0.1f, 100.0f);
861
862     glMatrixMode(GL_PROJECTION);
863     glPushMatrix();
864     loadMatrix(mat);
865
866     glMatrixMode(GL_MODELVIEW);
867     glPushMatrix();
868
869     QVector3D center;
870
871     for (int i = m_frame % N; i < m_cubemaps.size(); i += N) {
872         if (0 == m_cubemaps[i])
873             continue;
874
875         float angle = 2.0f * PI * i / m_cubemaps.size();
876
877         center = m_trackBalls[1].rotation().rotatedVector(QVector3D(cos(angle), sin(angle), 0.0f));
878
879         for (int face = 0; face < 6; ++face) {
880             m_cubemaps[i]->begin(face);
881
882             GLRenderTargetCube::getViewMatrix(mat, face);
883             QVector4D v = QVector4D(-center.x(), -center.y(), -center.z(), 1.0);
884             mat.setColumn(3, mat * v);
885
886             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
887             renderBoxes(mat, i);
888
889             m_cubemaps[i]->end();
890         }
891     }
892
893     for (int face = 0; face < 6; ++face) {
894         m_mainCubemap->begin(face);
895         GLRenderTargetCube::getViewMatrix(mat, face);
896
897         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
898         renderBoxes(mat, -1);
899
900         m_mainCubemap->end();
901     }
902
903     glPopMatrix();
904
905     glMatrixMode(GL_PROJECTION);
906     glPopMatrix();
907
908     m_updateAllCubemaps = false;
909 }
910
911 void Scene::drawBackground(QPainter *painter, const QRectF &)
912 {
913     float width = float(painter->device()->width());
914     float height = float(painter->device()->height());
915
916     painter->beginNativePainting();
917     setStates();
918
919     if (m_dynamicCubemap)
920         renderCubemaps();
921
922     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
923
924     glMatrixMode(GL_PROJECTION);
925     qgluPerspective(60.0, width / height, 0.01, 15.0);
926
927     glMatrixMode(GL_MODELVIEW);
928
929     QMatrix4x4 view;
930     view.rotate(m_trackBalls[2].rotation());
931     view(2, 3) -= 2.0f * exp(m_distExp / 1200.0f);
932     renderBoxes(view);
933
934     defaultStates();
935     ++m_frame;
936
937     painter->endNativePainting();
938 }
939
940 QPointF Scene::pixelPosToViewPos(const QPointF& p)
941 {
942     return QPointF(2.0 * float(p.x()) / width() - 1.0,
943                    1.0 - 2.0 * float(p.y()) / height());
944 }
945
946 void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
947 {
948     QGraphicsScene::mouseMoveEvent(event);
949     if (event->isAccepted())
950         return;
951
952     if (event->buttons() & Qt::LeftButton) {
953         m_trackBalls[0].move(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
954         event->accept();
955     } else {
956         m_trackBalls[0].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
957     }
958
959     if (event->buttons() & Qt::RightButton) {
960         m_trackBalls[1].move(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
961         event->accept();
962     } else {
963         m_trackBalls[1].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
964     }
965
966     if (event->buttons() & Qt::MidButton) {
967         m_trackBalls[2].move(pixelPosToViewPos(event->scenePos()), QQuaternion());
968         event->accept();
969     } else {
970         m_trackBalls[2].release(pixelPosToViewPos(event->scenePos()), QQuaternion());
971     }
972 }
973
974 void Scene::mousePressEvent(QGraphicsSceneMouseEvent *event)
975 {
976     QGraphicsScene::mousePressEvent(event);
977     if (event->isAccepted())
978         return;
979
980     if (event->buttons() & Qt::LeftButton) {
981         m_trackBalls[0].push(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
982         event->accept();
983     }
984
985     if (event->buttons() & Qt::RightButton) {
986         m_trackBalls[1].push(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
987         event->accept();
988     }
989
990     if (event->buttons() & Qt::MidButton) {
991         m_trackBalls[2].push(pixelPosToViewPos(event->scenePos()), QQuaternion());
992         event->accept();
993     }
994 }
995
996 void Scene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
997 {
998     QGraphicsScene::mouseReleaseEvent(event);
999     if (event->isAccepted())
1000         return;
1001
1002     if (event->button() == Qt::LeftButton) {
1003         m_trackBalls[0].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
1004         event->accept();
1005     }
1006
1007     if (event->button() == Qt::RightButton) {
1008         m_trackBalls[1].release(pixelPosToViewPos(event->scenePos()), m_trackBalls[2].rotation().conjugate());
1009         event->accept();
1010     }
1011
1012     if (event->button() == Qt::MidButton) {
1013         m_trackBalls[2].release(pixelPosToViewPos(event->scenePos()), QQuaternion());
1014         event->accept();
1015     }
1016 }
1017
1018 void Scene::wheelEvent(QGraphicsSceneWheelEvent * event)
1019 {
1020     QGraphicsScene::wheelEvent(event);
1021     if (!event->isAccepted()) {
1022         m_distExp += event->delta();
1023         if (m_distExp < -8 * 120)
1024             m_distExp = -8 * 120;
1025         if (m_distExp > 10 * 120)
1026             m_distExp = 10 * 120;
1027         event->accept();
1028     }
1029 }
1030
1031 void Scene::setShader(int index)
1032 {
1033     if (index >= 0 && index < m_fragmentShaders.size())
1034         m_currentShader = index;
1035 }
1036
1037 void Scene::setTexture(int index)
1038 {
1039     if (index >= 0 && index < m_textures.size())
1040         m_currentTexture = index;
1041 }
1042
1043 void Scene::toggleDynamicCubemap(int state)
1044 {
1045     if ((m_dynamicCubemap = (state == Qt::Checked)))
1046         m_updateAllCubemaps = true;
1047 }
1048
1049 void Scene::setColorParameter(const QString &name, QRgb color)
1050 {
1051     // set the color in all programs
1052     foreach (QGLShaderProgram *program, m_programs) {
1053         program->bind();
1054         program->setUniformValue(program->uniformLocation(name), QColor(color));
1055         program->release();
1056     }
1057 }
1058
1059 void Scene::setFloatParameter(const QString &name, float value)
1060 {
1061     // set the color in all programs
1062     foreach (QGLShaderProgram *program, m_programs) {
1063         program->bind();
1064         program->setUniformValue(program->uniformLocation(name), value);
1065         program->release();
1066     }
1067 }
1068
1069 void Scene::newItem(ItemDialog::ItemType type)
1070 {
1071     QSize size = sceneRect().size().toSize();
1072     switch (type) {
1073     case ItemDialog::QtBoxItem:
1074         addItem(new QtBox(64, rand() % (size.width() - 64) + 32, rand() % (size.height() - 64) + 32));
1075         break;
1076     case ItemDialog::CircleItem:
1077         addItem(new CircleItem(64, rand() % (size.width() - 64) + 32, rand() % (size.height() - 64) + 32));
1078         break;
1079     case ItemDialog::SquareItem:
1080         addItem(new SquareItem(64, rand() % (size.width() - 64) + 32, rand() % (size.height() - 64) + 32));
1081         break;
1082     default:
1083         break;
1084     }
1085 }