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#ifdef BUILD_GL
 15#include "platform/opengl/gl.h"
 16#endif
 17#if !defined(_WIN32) || defined(USE_EPOXY)
 18#include "platform/opengl/gles2.h"
 19#ifdef _WIN32 
 20#include <epoxy/wgl.h>
 21#endif
 22#endif
 23}
 24
 25using namespace QGBA;
 26
 27DisplayGL::DisplayGL(const QGLFormat& format, QWidget* parent)
 28	: Display(parent)
 29	, m_isDrawing(false)
 30	, m_gl(new EmptyGLWidget(format, this))
 31	, m_drawThread(nullptr)
 32	, m_context(nullptr)
 33{
 34	m_painter = new PainterGL(m_gl, QGLFormat::openGLVersionFlags());
 35	m_gl->setMouseTracking(true);
 36	m_gl->setAttribute(Qt::WA_TransparentForMouseEvents); // This doesn't seem to work?
 37}
 38
 39DisplayGL::~DisplayGL() {
 40	delete m_painter;
 41}
 42
 43void DisplayGL::startDrawing(GBAThread* thread) {
 44	if (m_drawThread) {
 45		return;
 46	}
 47	m_isDrawing = true;
 48	m_painter->setContext(thread);
 49	m_painter->setMessagePainter(messagePainter());
 50	m_context = thread;
 51	m_painter->resize(size());
 52	m_gl->move(0, 0);
 53	m_drawThread = new QThread(this);
 54	m_drawThread->setObjectName("Painter Thread");
 55	m_gl->context()->doneCurrent();
 56	m_gl->context()->moveToThread(m_drawThread);
 57	m_painter->moveToThread(m_drawThread);
 58	connect(m_drawThread, SIGNAL(started()), m_painter, SLOT(start()));
 59	m_drawThread->start();
 60	GBASyncSetVideoSync(&m_context->sync, false);
 61
 62	lockAspectRatio(isAspectRatioLocked());
 63	filter(isFiltered());
 64	messagePainter()->resize(size(), isAspectRatioLocked(), devicePixelRatio());
 65	resizePainter();
 66}
 67
 68void DisplayGL::stopDrawing() {
 69	if (m_drawThread) {
 70		m_isDrawing = false;
 71		if (GBAThreadIsActive(m_context)) {
 72			GBAThreadInterrupt(m_context);
 73		}
 74		QMetaObject::invokeMethod(m_painter, "stop", Qt::BlockingQueuedConnection);
 75		m_drawThread->exit();
 76		m_drawThread = nullptr;
 77		if (GBAThreadIsActive(m_context)) {
 78			GBAThreadContinue(m_context);
 79		}
 80	}
 81}
 82
 83void DisplayGL::pauseDrawing() {
 84	if (m_drawThread) {
 85		m_isDrawing = false;
 86		if (GBAThreadIsActive(m_context)) {
 87			GBAThreadInterrupt(m_context);
 88		}
 89		QMetaObject::invokeMethod(m_painter, "pause", Qt::BlockingQueuedConnection);
 90		if (GBAThreadIsActive(m_context)) {
 91			GBAThreadContinue(m_context);
 92		}
 93	}
 94}
 95
 96void DisplayGL::unpauseDrawing() {
 97	if (m_drawThread) {
 98		m_isDrawing = true;
 99		if (GBAThreadIsActive(m_context)) {
100			GBAThreadInterrupt(m_context);
101		}
102		QMetaObject::invokeMethod(m_painter, "unpause", Qt::BlockingQueuedConnection);
103		if (GBAThreadIsActive(m_context)) {
104			GBAThreadContinue(m_context);
105		}
106	}
107}
108
109void DisplayGL::forceDraw() {
110	if (m_drawThread) {
111		QMetaObject::invokeMethod(m_painter, "forceDraw");
112	}
113}
114
115void DisplayGL::lockAspectRatio(bool lock) {
116	Display::lockAspectRatio(lock);
117	if (m_drawThread) {
118		QMetaObject::invokeMethod(m_painter, "lockAspectRatio", Q_ARG(bool, lock));
119	}
120}
121
122void DisplayGL::filter(bool filter) {
123	Display::filter(filter);
124	if (m_drawThread) {
125		QMetaObject::invokeMethod(m_painter, "filter", Q_ARG(bool, filter));
126	}
127}
128
129void DisplayGL::framePosted(const uint32_t* buffer) {
130	if (m_drawThread && buffer) {
131		m_painter->enqueue(buffer);
132		QMetaObject::invokeMethod(m_painter, "draw");
133	}
134}
135
136void DisplayGL::resizeEvent(QResizeEvent* event) {
137	Display::resizeEvent(event);
138	resizePainter();
139}
140
141void DisplayGL::resizePainter() {
142	m_gl->resize(size());
143	if (m_drawThread) {
144		QMetaObject::invokeMethod(m_painter, "resize", Qt::BlockingQueuedConnection, Q_ARG(QSize, size()));
145	}
146}
147
148PainterGL::PainterGL(QGLWidget* parent, QGLFormat::OpenGLVersionFlags glVersion)
149	: m_gl(parent)
150	, m_active(false)
151	, m_context(nullptr)
152	, m_messagePainter(nullptr)
153{
154#ifdef BUILD_GL
155	GBAGLContext* glBackend;
156#endif
157#if !defined(_WIN32) || defined(USE_EPOXY)
158	GBAGLES2Context* gl2Backend;
159#endif
160
161#if !defined(_WIN32) || defined(USE_EPOXY)
162	if (glVersion & QGLFormat::OpenGL_Version_3_0) {
163		gl2Backend = new GBAGLES2Context;
164		GBAGLES2ContextCreate(gl2Backend);
165		m_backend = &gl2Backend->d;
166	} else {
167#else
168	{
169#endif
170		glBackend = new GBAGLContext;
171		GBAGLContextCreate(glBackend);
172		m_backend = &glBackend->d;
173	}
174	m_backend->swap = [](VideoBackend* v) {
175		PainterGL* painter = static_cast<PainterGL*>(v->user);
176		painter->m_gl->swapBuffers();
177	};
178	m_backend->user = this;
179	m_backend->filter = false;
180	m_backend->lockAspectRatio = false;
181
182	for (int i = 0; i < 2; ++i) {
183		m_free.append(new uint32_t[256 * 256]);
184	}
185}
186
187PainterGL::~PainterGL() {
188	while (!m_queue.isEmpty()) {
189		delete[] m_queue.dequeue();
190	}
191	for (auto item : m_free) {
192		delete[] item;
193	}
194	delete m_backend;
195	m_backend = nullptr;
196}
197
198void PainterGL::setContext(GBAThread* context) {
199	m_context = context;
200}
201
202void PainterGL::setMessagePainter(MessagePainter* messagePainter) {
203	m_messagePainter = messagePainter;
204}
205
206void PainterGL::resize(const QSize& size) {
207	m_size = size;
208	if (m_active) {
209		forceDraw();
210	}
211}
212
213void PainterGL::lockAspectRatio(bool lock) {
214	m_backend->lockAspectRatio = lock;
215	if (m_active) {
216		forceDraw();
217	}
218}
219
220void PainterGL::filter(bool filter) {
221	m_backend->filter = filter;
222	if (m_active) {
223		forceDraw();
224	}
225}
226
227void PainterGL::start() {
228	m_gl->makeCurrent();
229#if defined(_WIN32) && defined(USE_EPOXY)
230	epoxy_handle_external_wglMakeCurrent();
231#endif
232	m_backend->init(m_backend, reinterpret_cast<WHandle>(m_gl->winId()));
233	m_gl->doneCurrent();
234	m_active = true;
235}
236
237void PainterGL::draw() {
238	if (m_queue.isEmpty() || !GBAThreadIsActive(m_context)) {
239		return;
240	}
241	if (GBASyncWaitFrameStart(&m_context->sync) || !m_queue.isEmpty()) {
242		dequeue();
243		m_painter.begin(m_gl->context()->device());
244		performDraw();
245		m_painter.end();
246		GBASyncWaitFrameEnd(&m_context->sync);
247		m_backend->swap(m_backend);
248	} else {
249		GBASyncWaitFrameEnd(&m_context->sync);
250	}
251	if (!m_queue.isEmpty()) {
252		QMetaObject::invokeMethod(this, "draw", Qt::QueuedConnection);
253	}
254}
255
256void PainterGL::forceDraw() {
257	m_painter.begin(m_gl->context()->device());
258	performDraw();
259	m_painter.end();
260	m_backend->swap(m_backend);
261}
262
263void PainterGL::stop() {
264	m_active = false;
265	m_gl->makeCurrent();
266#if defined(_WIN32) && defined(USE_EPOXY)
267	epoxy_handle_external_wglMakeCurrent();
268#endif
269	dequeueAll();
270	m_backend->clear(m_backend);
271	m_backend->swap(m_backend);
272	m_backend->deinit(m_backend);
273	m_gl->doneCurrent();
274	m_gl->context()->moveToThread(m_gl->thread());
275	moveToThread(m_gl->thread());
276}
277
278void PainterGL::pause() {
279	m_active = false;
280}
281
282void PainterGL::unpause() {
283	m_active = true;
284}
285
286void PainterGL::performDraw() {
287	m_painter.beginNativePainting();
288	float r = m_gl->devicePixelRatio();
289	m_backend->resized(m_backend, m_size.width() * r, m_size.height() * r);
290	m_backend->drawFrame(m_backend);
291	m_painter.endNativePainting();
292	if (m_messagePainter) {
293		m_messagePainter->paint(&m_painter);
294	}
295}
296
297void PainterGL::enqueue(const uint32_t* backing) {
298	m_mutex.lock();
299	uint32_t* buffer;
300	if (m_free.isEmpty()) {
301		buffer = m_queue.dequeue();
302	} else {
303		buffer = m_free.takeLast();
304	}
305	memcpy(buffer, backing, 256 * VIDEO_VERTICAL_PIXELS * BYTES_PER_PIXEL);
306	m_queue.enqueue(buffer);
307	m_mutex.unlock();
308}
309
310void PainterGL::dequeue() {
311	m_mutex.lock();
312	if (m_queue.isEmpty()) {
313		m_mutex.unlock();
314		return;
315	}
316	uint32_t* buffer = m_queue.dequeue();
317	m_backend->postFrame(m_backend, buffer);
318	m_free.append(buffer);
319	m_mutex.unlock();
320}
321
322void PainterGL::dequeueAll() {
323	uint32_t* buffer = 0;
324	m_mutex.lock();
325	while (!m_queue.isEmpty()) {
326		buffer = m_queue.dequeue();
327		m_free.append(buffer);
328	}
329	if (buffer) {
330		m_backend->postFrame(m_backend, buffer);
331	}
332	m_mutex.unlock();
333}