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_context(nullptr)
 23{
 24	m_gl->setMouseTracking(true);
 25	m_gl->setAttribute(Qt::WA_TransparentForMouseEvents); // This doesn't seem to work?
 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_painter->setMessagePainter(messagePainter());
 38	m_context = thread;
 39	m_painter->resize(size());
 40	m_gl->move(0, 0);
 41	m_drawThread = new QThread(this);
 42	m_drawThread->setObjectName("Painter Thread");
 43	m_gl->context()->doneCurrent();
 44	m_gl->context()->moveToThread(m_drawThread);
 45	m_painter->moveToThread(m_drawThread);
 46	connect(m_drawThread, SIGNAL(started()), m_painter, SLOT(start()));
 47	m_drawThread->start();
 48	GBASyncSetVideoSync(&m_context->sync, false);
 49
 50	lockAspectRatio(isAspectRatioLocked());
 51	filter(isFiltered());
 52	messagePainter()->resize(size(), isAspectRatioLocked(), devicePixelRatio());
 53	resizePainter();
 54}
 55
 56void DisplayGL::stopDrawing() {
 57	if (m_drawThread) {
 58		if (GBAThreadIsActive(m_context)) {
 59			GBAThreadInterrupt(m_context);
 60		}
 61		QMetaObject::invokeMethod(m_painter, "stop", Qt::BlockingQueuedConnection);
 62		m_drawThread->exit();
 63		m_drawThread = nullptr;
 64		if (GBAThreadIsActive(m_context)) {
 65			GBAThreadContinue(m_context);
 66		}
 67	}
 68}
 69
 70void DisplayGL::pauseDrawing() {
 71	if (m_drawThread) {
 72		if (GBAThreadIsActive(m_context)) {
 73			GBAThreadInterrupt(m_context);
 74		}
 75		QMetaObject::invokeMethod(m_painter, "pause", Qt::BlockingQueuedConnection);
 76		if (GBAThreadIsActive(m_context)) {
 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		}
 87		QMetaObject::invokeMethod(m_painter, "unpause", Qt::BlockingQueuedConnection);
 88		if (GBAThreadIsActive(m_context)) {
 89			GBAThreadContinue(m_context);
 90		}
 91	}
 92}
 93
 94void DisplayGL::forceDraw() {
 95	if (m_drawThread) {
 96		QMetaObject::invokeMethod(m_painter, "forceDraw");
 97	}
 98}
 99
100void DisplayGL::lockAspectRatio(bool lock) {
101	Display::lockAspectRatio(lock);
102	if (m_drawThread) {
103		QMetaObject::invokeMethod(m_painter, "lockAspectRatio", Q_ARG(bool, lock));
104	}
105}
106
107void DisplayGL::filter(bool filter) {
108	Display::filter(filter);
109	if (m_drawThread) {
110		QMetaObject::invokeMethod(m_painter, "filter", Q_ARG(bool, filter));
111	}
112}
113
114void DisplayGL::framePosted(const uint32_t* buffer) {
115	if (m_drawThread && buffer) {
116		QMetaObject::invokeMethod(m_painter, "setBacking", Q_ARG(const uint32_t*, buffer));
117	}
118}
119
120void DisplayGL::resizeEvent(QResizeEvent* event) {
121	Display::resizeEvent(event);
122	resizePainter();
123}
124
125void DisplayGL::resizePainter() {
126	m_gl->resize(size());
127	if (m_drawThread) {
128		QMetaObject::invokeMethod(m_painter, "resize", Qt::BlockingQueuedConnection, Q_ARG(QSize, size()));
129	}
130}
131
132PainterGL::PainterGL(QGLWidget* parent)
133	: m_gl(parent)
134	, m_active(false)
135	, m_context(nullptr)
136	, m_messagePainter(nullptr)
137{
138#ifdef BUILD_GL
139	GBAGLContextCreate(&m_backend);
140#elif defined(BUILD_GLES2)
141	GBAGLES2ContextCreate(&m_backend);
142#endif
143	m_backend.d.swap = [](VideoBackend* v) {
144		PainterGL* painter = static_cast<PainterGL*>(v->user);
145		painter->m_gl->swapBuffers();
146	};
147	m_backend.d.user = this;
148	m_backend.d.filter = false;
149	m_backend.d.lockAspectRatio = false;
150}
151
152void PainterGL::setContext(GBAThread* context) {
153	m_context = context;
154}
155
156void PainterGL::setMessagePainter(MessagePainter* messagePainter) {
157	m_messagePainter = messagePainter;
158}
159
160void PainterGL::setBacking(const uint32_t* backing) {
161	m_gl->makeCurrent();
162	m_backend.d.postFrame(&m_backend.d, backing);
163	if (m_active) {
164		draw();
165	}
166	m_gl->doneCurrent();
167}
168
169void PainterGL::resize(const QSize& size) {
170	m_size = size;
171	if (m_active) {
172		forceDraw();
173	}
174}
175
176void PainterGL::lockAspectRatio(bool lock) {
177	m_backend.d.lockAspectRatio = lock;
178	if (m_active) {
179		forceDraw();
180	}
181}
182
183void PainterGL::filter(bool filter) {
184	m_backend.d.filter = filter;
185	if (m_active) {
186		forceDraw();
187	}
188}
189
190void PainterGL::start() {
191	m_gl->makeCurrent();
192	m_backend.d.init(&m_backend.d, reinterpret_cast<WHandle>(m_gl->winId()));
193	m_gl->doneCurrent();
194	m_active = true;
195}
196
197void PainterGL::draw() {
198	if (GBASyncWaitFrameStart(&m_context->sync, m_context->frameskip)) {
199		m_painter.begin(m_gl->context()->device());
200		performDraw();
201		m_painter.end();
202		GBASyncWaitFrameEnd(&m_context->sync);
203		m_backend.d.swap(&m_backend.d);
204	} else {
205		GBASyncWaitFrameEnd(&m_context->sync);
206	}
207}
208
209void PainterGL::forceDraw() {
210	m_painter.begin(m_gl->context()->device());
211	performDraw();
212	m_painter.end();
213	m_backend.d.swap(&m_backend.d);
214}
215
216void PainterGL::stop() {
217	m_active = false;
218	m_gl->makeCurrent();
219	m_backend.d.clear(&m_backend.d);
220	m_backend.d.swap(&m_backend.d);
221	m_backend.d.deinit(&m_backend.d);
222	m_gl->doneCurrent();
223	m_gl->context()->moveToThread(m_gl->thread());
224	moveToThread(m_gl->thread());
225}
226
227void PainterGL::pause() {
228	m_active = false;
229	// Make sure both buffers are filled
230	forceDraw();
231	forceDraw();
232}
233
234void PainterGL::unpause() {
235	m_active = true;
236}
237
238void PainterGL::performDraw() {
239	m_painter.beginNativePainting();
240	float r = m_gl->devicePixelRatio();
241	m_backend.d.resized(&m_backend.d, m_size.width() * r, m_size.height() * r);
242	m_backend.d.drawFrame(&m_backend.d);
243	m_painter.endNativePainting();
244	if (m_messagePainter) {
245		m_messagePainter->paint(&m_painter);
246	}
247}