1/* Copyright (c) 2013-2015 Jeffrey Pfau
  2 *
  3 * This Source Code Form is subject to the terms of the Mozilla Public
  4 * License, v. 2.0. If a copy of the MPL was not distributed with this
  5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  6#include "DisplayGL.h"
  7
  8#include <QApplication>
  9#include <QResizeEvent>
 10
 11extern "C" {
 12#include "gba/supervisor/thread.h"
 13}
 14
 15using namespace QGBA;
 16
 17DisplayGL::DisplayGL(const QGLFormat& format, QWidget* parent)
 18	: Display(parent)
 19	, m_gl(new EmptyGLWidget(format, this))
 20	, m_painter(new PainterGL(m_gl))
 21	, m_drawThread(nullptr)
 22	, m_lockAspectRatio(false)
 23	, m_filter(false)
 24	, m_context(nullptr)
 25{
 26}
 27
 28DisplayGL::~DisplayGL() {
 29	delete m_painter;
 30}
 31
 32void DisplayGL::startDrawing(GBAThread* thread) {
 33	if (m_drawThread) {
 34		return;
 35	}
 36	m_painter->setContext(thread);
 37	m_context = thread;
 38	m_painter->resize(size());
 39	m_gl->move(0, 0);
 40	m_drawThread = new QThread(this);
 41	m_gl->context()->doneCurrent();
 42	m_gl->context()->moveToThread(m_drawThread);
 43	m_painter->moveToThread(m_drawThread);
 44	connect(m_drawThread, SIGNAL(started()), m_painter, SLOT(start()));
 45	m_drawThread->start();
 46
 47	lockAspectRatio(m_lockAspectRatio);
 48	filter(m_filter);
 49	resizePainter();
 50}
 51
 52void DisplayGL::stopDrawing() {
 53	if (m_drawThread) {
 54		if (GBAThreadIsActive(m_context)) {
 55			GBAThreadInterrupt(m_context);
 56			GBASyncSuspendDrawing(&m_context->sync);
 57		}
 58		QMetaObject::invokeMethod(m_painter, "stop", Qt::BlockingQueuedConnection);
 59		m_drawThread->exit();
 60		m_drawThread = nullptr;
 61		if (GBAThreadIsActive(m_context)) {
 62			GBASyncResumeDrawing(&m_context->sync);
 63			GBAThreadContinue(m_context);
 64		}
 65	}
 66}
 67
 68void DisplayGL::pauseDrawing() {
 69	if (m_drawThread) {
 70		if (GBAThreadIsActive(m_context)) {
 71			GBAThreadInterrupt(m_context);
 72			GBASyncSuspendDrawing(&m_context->sync);
 73		}
 74		QMetaObject::invokeMethod(m_painter, "pause", Qt::BlockingQueuedConnection);
 75		if (GBAThreadIsActive(m_context)) {
 76			GBASyncResumeDrawing(&m_context->sync);
 77			GBAThreadContinue(m_context);
 78		}
 79	}
 80}
 81
 82void DisplayGL::unpauseDrawing() {
 83	if (m_drawThread) {
 84		if (GBAThreadIsActive(m_context)) {
 85			GBAThreadInterrupt(m_context);
 86			GBASyncSuspendDrawing(&m_context->sync);
 87		}
 88		QMetaObject::invokeMethod(m_painter, "unpause", Qt::BlockingQueuedConnection);
 89		if (GBAThreadIsActive(m_context)) {
 90			GBASyncResumeDrawing(&m_context->sync);
 91			GBAThreadContinue(m_context);
 92		}
 93	}
 94}
 95
 96void DisplayGL::forceDraw() {
 97	if (m_drawThread) {
 98		QMetaObject::invokeMethod(m_painter, "forceDraw");
 99	}
100}
101
102void DisplayGL::lockAspectRatio(bool lock) {
103	m_lockAspectRatio = lock;
104	if (m_drawThread) {
105		QMetaObject::invokeMethod(m_painter, "lockAspectRatio", Q_ARG(bool, lock));
106	}
107}
108
109void DisplayGL::filter(bool filter) {
110	m_filter = filter;
111	if (m_drawThread) {
112		QMetaObject::invokeMethod(m_painter, "filter", Q_ARG(bool, filter));
113	}
114}
115
116void DisplayGL::framePosted(const uint32_t* buffer) {
117	if (m_drawThread && buffer) {
118		QMetaObject::invokeMethod(m_painter, "setBacking", Q_ARG(const uint32_t*, buffer));
119	}
120}
121
122void DisplayGL::showMessage(const QString& message) {
123	if (m_drawThread) {
124		QMetaObject::invokeMethod(m_painter, "showMessage", Q_ARG(const QString&, message));
125	}
126}
127
128void DisplayGL::resizeEvent(QResizeEvent*) {
129	resizePainter();
130}
131
132void DisplayGL::resizePainter() {
133	m_gl->resize(size());
134	if (m_drawThread) {
135		QMetaObject::invokeMethod(m_painter, "resize", Qt::BlockingQueuedConnection, Q_ARG(QSize, size()));
136	}
137}
138
139PainterGL::PainterGL(QGLWidget* parent)
140	: m_gl(parent)
141	, m_drawTimer(nullptr)
142	, m_messageTimer(this)
143	, m_context(nullptr)
144{
145	GBAGLContextCreate(&m_backend);
146	m_backend.d.swap = [](VideoBackend* v) {
147		PainterGL* painter = static_cast<PainterGL*>(v->user);
148		painter->m_gl->swapBuffers();
149	};
150	m_backend.d.user = this;
151	m_backend.d.filter = false;
152	m_backend.d.lockAspectRatio = false;
153	m_messageFont.setFamily("Source Code Pro");
154	m_messageFont.setStyleHint(QFont::Monospace);
155	m_messageFont.setPixelSize(13);
156	connect(&m_messageTimer, SIGNAL(timeout()), this, SLOT(clearMessage()));
157	m_messageTimer.setSingleShot(true);
158	m_messageTimer.setInterval(5000);
159
160	clearMessage();
161}
162
163void PainterGL::setContext(GBAThread* context) {
164	m_context = context;
165}
166
167void PainterGL::setBacking(const uint32_t* backing) {
168	m_gl->makeCurrent();
169	m_backend.d.postFrame(&m_backend.d, backing);
170	m_gl->doneCurrent();
171}
172
173void PainterGL::resize(const QSize& size) {
174	m_size = size;
175	int w = m_size.width();
176	int h = m_size.height();
177	int drawW = w;
178	int drawH = h;
179	if (m_backend.d.lockAspectRatio) {
180		if (w * 2 > h * 3) {
181			drawW = h * 3 / 2;
182		} else if (w * 2 < h * 3) {
183			drawH = w * 2 / 3;
184		}
185	}
186	m_world.reset();
187	m_world.translate((w - drawW) / 2, (h - drawH) / 2);
188	m_world.scale(qreal(drawW) / VIDEO_HORIZONTAL_PIXELS, qreal(drawH) / VIDEO_VERTICAL_PIXELS);
189	m_message.prepare(m_world, m_messageFont);
190	if (m_drawTimer) {
191		forceDraw();
192	}
193}
194
195void PainterGL::lockAspectRatio(bool lock) {
196	m_backend.d.lockAspectRatio = lock;
197	if (m_drawTimer) {
198		forceDraw();
199	}
200}
201
202void PainterGL::filter(bool filter) {
203	m_backend.d.filter = filter;
204	if (m_drawTimer) {
205		forceDraw();
206	}
207}
208
209void PainterGL::start() {
210	m_gl->makeCurrent();
211	m_backend.d.init(&m_backend.d, (void*) m_gl->winId());
212	m_gl->doneCurrent();
213
214	m_drawTimer = new QTimer;
215	m_drawTimer->moveToThread(QThread::currentThread());
216	m_drawTimer->setInterval(0);
217	connect(m_drawTimer, SIGNAL(timeout()), this, SLOT(draw()));
218	m_drawTimer->start();
219}
220
221void PainterGL::draw() {
222	GBASyncWaitFrameStart(&m_context->sync, m_context->frameskip);
223	m_painter.begin(m_gl->context()->device());
224	performDraw();
225	m_painter.end();
226	GBASyncWaitFrameEnd(&m_context->sync);
227	m_backend.d.swap(&m_backend.d);
228}
229
230void PainterGL::forceDraw() {
231	m_painter.begin(m_gl->context()->device());
232	performDraw();
233	m_painter.end();
234	m_backend.d.swap(&m_backend.d);
235}
236
237void PainterGL::stop() {
238	m_drawTimer->stop();
239	delete m_drawTimer;
240	m_drawTimer = nullptr;
241	m_gl->makeCurrent();
242	m_backend.d.clear(&m_backend.d);
243	m_backend.d.swap(&m_backend.d);
244	m_backend.d.deinit(&m_backend.d);
245	m_gl->doneCurrent();
246	m_gl->context()->moveToThread(m_gl->thread());
247	moveToThread(m_gl->thread());
248}
249
250void PainterGL::pause() {
251	m_drawTimer->stop();
252	// Make sure both buffers are filled
253	forceDraw();
254	forceDraw();
255}
256
257void PainterGL::unpause() {
258	m_drawTimer->start();
259}
260
261void PainterGL::performDraw() {
262	m_painter.beginNativePainting();
263	float r = m_gl->devicePixelRatio();
264	m_backend.d.resized(&m_backend.d, m_size.width() * r, m_size.height() * r);
265	m_backend.d.drawFrame(&m_backend.d);
266	m_painter.endNativePainting();
267	m_painter.setWorldTransform(m_world);
268	m_painter.setRenderHint(QPainter::Antialiasing);
269	m_painter.setFont(m_messageFont);
270	m_painter.setPen(Qt::black);
271	m_painter.translate(1, VIDEO_VERTICAL_PIXELS - m_messageFont.pixelSize() - 1);
272	for (int i = 0; i < 16; ++i) {
273		m_painter.save();
274		m_painter.translate(cos(i * M_PI / 8.0) * 0.8, sin(i * M_PI / 8.0) * 0.8);
275		m_painter.drawStaticText(0, 0, m_message);
276		m_painter.restore();
277	}
278	m_painter.setPen(Qt::white);
279	m_painter.drawStaticText(0, 0, m_message);
280}
281
282void PainterGL::showMessage(const QString& message) {
283	m_message.setText(message);
284	m_message.prepare(m_world, m_messageFont);
285	m_messageTimer.stop();
286	m_messageTimer.start();
287}
288
289void PainterGL::clearMessage() {
290	m_message.setText(QString());
291}