src/platform/qt/DisplayGL.cpp (view raw)
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
11#include <mgba/core/core.h>
12#include <mgba/core/thread.h>
13#ifdef BUILD_GL
14#include "platform/opengl/gl.h"
15#endif
16#if !defined(_WIN32) || defined(USE_EPOXY)
17#include "platform/opengl/gles2.h"
18#ifdef _WIN32
19#include <epoxy/wgl.h>
20#endif
21#endif
22
23using namespace QGBA;
24
25DisplayGL::DisplayGL(const QGLFormat& format, QWidget* parent)
26 : Display(parent)
27 , m_isDrawing(false)
28 , m_gl(new EmptyGLWidget(format, this))
29 , m_drawThread(nullptr)
30 , m_context(nullptr)
31{
32 m_painter = new PainterGL(format.majorVersion() < 2 ? 1 : m_gl->format().majorVersion(), m_gl);
33 m_gl->setMouseTracking(true);
34 m_gl->setAttribute(Qt::WA_TransparentForMouseEvents); // This doesn't seem to work?
35}
36
37DisplayGL::~DisplayGL() {
38 delete m_painter;
39}
40
41bool DisplayGL::supportsShaders() const {
42 return m_painter->supportsShaders();
43}
44
45VideoShader* DisplayGL::shaders() {
46 VideoShader* shaders = nullptr;
47 if (m_drawThread) {
48 QMetaObject::invokeMethod(m_painter, "shaders", Qt::BlockingQueuedConnection, Q_RETURN_ARG(VideoShader*, shaders));
49 } else {
50 shaders = m_painter->shaders();
51 }
52 return shaders;
53}
54
55void DisplayGL::startDrawing(mCoreThread* thread) {
56 if (m_drawThread) {
57 return;
58 }
59 m_isDrawing = true;
60 m_painter->setContext(thread);
61 m_painter->setMessagePainter(messagePainter());
62 m_context = thread;
63 m_painter->resize(size());
64 m_gl->move(0, 0);
65 m_drawThread = new QThread(this);
66 m_drawThread->setObjectName("Painter Thread");
67 m_gl->context()->doneCurrent();
68 m_gl->context()->moveToThread(m_drawThread);
69 m_painter->moveToThread(m_drawThread);
70 connect(m_drawThread, SIGNAL(started()), m_painter, SLOT(start()));
71 m_drawThread->start();
72 mCoreSyncSetVideoSync(&m_context->sync, false);
73
74 lockAspectRatio(isAspectRatioLocked());
75 filter(isFiltered());
76 messagePainter()->resize(size(), isAspectRatioLocked(), devicePixelRatio());
77 resizePainter();
78}
79
80void DisplayGL::stopDrawing() {
81 if (m_drawThread) {
82 m_isDrawing = false;
83 if (mCoreThreadIsActive(m_context)) {
84 mCoreThreadInterrupt(m_context);
85 }
86 QMetaObject::invokeMethod(m_painter, "stop", Qt::BlockingQueuedConnection);
87 m_drawThread->exit();
88 m_drawThread = nullptr;
89 if (mCoreThreadIsActive(m_context)) {
90 mCoreThreadContinue(m_context);
91 }
92 }
93}
94
95void DisplayGL::pauseDrawing() {
96 if (m_drawThread) {
97 m_isDrawing = false;
98 if (mCoreThreadIsActive(m_context)) {
99 mCoreThreadInterrupt(m_context);
100 }
101 QMetaObject::invokeMethod(m_painter, "pause", Qt::BlockingQueuedConnection);
102 if (mCoreThreadIsActive(m_context)) {
103 mCoreThreadContinue(m_context);
104 }
105 }
106}
107
108void DisplayGL::unpauseDrawing() {
109 if (m_drawThread) {
110 m_isDrawing = true;
111 if (mCoreThreadIsActive(m_context)) {
112 mCoreThreadInterrupt(m_context);
113 }
114 QMetaObject::invokeMethod(m_painter, "unpause", Qt::BlockingQueuedConnection);
115 if (mCoreThreadIsActive(m_context)) {
116 mCoreThreadContinue(m_context);
117 }
118 }
119}
120
121void DisplayGL::forceDraw() {
122 if (m_drawThread) {
123 QMetaObject::invokeMethod(m_painter, "forceDraw");
124 }
125}
126
127void DisplayGL::lockAspectRatio(bool lock) {
128 Display::lockAspectRatio(lock);
129 if (m_drawThread) {
130 QMetaObject::invokeMethod(m_painter, "lockAspectRatio", Q_ARG(bool, lock));
131 }
132}
133
134void DisplayGL::filter(bool filter) {
135 Display::filter(filter);
136 if (m_drawThread) {
137 QMetaObject::invokeMethod(m_painter, "filter", Q_ARG(bool, filter));
138 }
139}
140
141void DisplayGL::framePosted(const uint32_t* buffer) {
142 if (m_drawThread && buffer) {
143 m_painter->enqueue(buffer);
144 QMetaObject::invokeMethod(m_painter, "draw");
145 }
146}
147
148void DisplayGL::setShaders(struct VDir* shaders) {
149 if (m_drawThread) {
150 QMetaObject::invokeMethod(m_painter, "setShaders", Qt::BlockingQueuedConnection, Q_ARG(struct VDir*, shaders));
151 } else {
152 m_painter->setShaders(shaders);
153 }
154}
155
156void DisplayGL::clearShaders() {
157 QMetaObject::invokeMethod(m_painter, "clearShaders");
158}
159
160void DisplayGL::resizeEvent(QResizeEvent* event) {
161 Display::resizeEvent(event);
162 resizePainter();
163}
164
165void DisplayGL::resizePainter() {
166 m_gl->resize(size());
167 if (m_drawThread) {
168 QMetaObject::invokeMethod(m_painter, "resize", Qt::BlockingQueuedConnection, Q_ARG(QSize, size()));
169 }
170}
171
172PainterGL::PainterGL(int majorVersion, QGLWidget* parent)
173 : m_gl(parent)
174 , m_active(false)
175 , m_started(false)
176 , m_context(nullptr)
177 , m_shader{}
178 , m_backend(nullptr)
179 , m_messagePainter(nullptr)
180{
181#ifdef BUILD_GL
182 mGLContext* glBackend;
183#endif
184#if !defined(_WIN32) || defined(USE_EPOXY)
185 mGLES2Context* gl2Backend;
186#endif
187
188#if !defined(_WIN32) || defined(USE_EPOXY)
189 if (majorVersion >= 2) {
190 gl2Backend = new mGLES2Context;
191 mGLES2ContextCreate(gl2Backend);
192 m_backend = &gl2Backend->d;
193 m_supportsShaders = true;
194 }
195#endif
196
197#ifdef BUILD_GL
198 if (!m_backend) {
199 glBackend = new mGLContext;
200 mGLContextCreate(glBackend);
201 m_backend = &glBackend->d;
202 m_supportsShaders = false;
203 }
204#endif
205 m_backend->swap = [](VideoBackend* v) {
206 PainterGL* painter = static_cast<PainterGL*>(v->user);
207 painter->m_gl->swapBuffers();
208 };
209
210 m_gl->makeCurrent();
211#if defined(_WIN32) && defined(USE_EPOXY)
212 epoxy_handle_external_wglMakeCurrent();
213#endif
214 m_backend->init(m_backend, reinterpret_cast<WHandle>(m_gl->winId()));
215#if !defined(_WIN32) || defined(USE_EPOXY)
216 if (m_supportsShaders) {
217 m_shader.preprocessShader = static_cast<void*>(&reinterpret_cast<mGLES2Context*>(m_backend)->initialShader);
218 }
219#endif
220 m_gl->doneCurrent();
221
222 m_backend->user = this;
223 m_backend->filter = false;
224 m_backend->lockAspectRatio = false;
225
226 for (int i = 0; i < 2; ++i) {
227 m_free.append(new uint32_t[256 * 256]);
228 }
229}
230
231PainterGL::~PainterGL() {
232 while (!m_queue.isEmpty()) {
233 delete[] m_queue.dequeue();
234 }
235 for (auto item : m_free) {
236 delete[] item;
237 }
238 m_gl->makeCurrent();
239#if defined(_WIN32) && defined(USE_EPOXY)
240 epoxy_handle_external_wglMakeCurrent();
241#endif
242#if !defined(_WIN32) || defined(USE_EPOXY)
243 if (m_shader.passes) {
244 mGLES2ShaderFree(&m_shader);
245 }
246#endif
247 m_backend->deinit(m_backend);
248 m_gl->doneCurrent();
249 delete m_backend;
250 m_backend = nullptr;
251}
252
253void PainterGL::setContext(mCoreThread* context) {
254 m_context = context;
255
256 if (!context) {
257 return;
258 }
259
260 m_gl->makeCurrent();
261#if defined(_WIN32) && defined(USE_EPOXY)
262 epoxy_handle_external_wglMakeCurrent();
263#endif
264 unsigned width, height;
265 context->core->desiredVideoDimensions(context->core, &width, &height);
266 m_backend->setDimensions(m_backend, width, height);
267 m_gl->doneCurrent();
268}
269
270void PainterGL::setMessagePainter(MessagePainter* messagePainter) {
271 m_messagePainter = messagePainter;
272}
273
274void PainterGL::resize(const QSize& size) {
275 m_size = size;
276 if (m_started && !m_active) {
277 forceDraw();
278 }
279}
280
281void PainterGL::lockAspectRatio(bool lock) {
282 m_backend->lockAspectRatio = lock;
283 if (m_started && !m_active) {
284 forceDraw();
285 }
286}
287
288void PainterGL::filter(bool filter) {
289 m_backend->filter = filter;
290 if (m_started && !m_active) {
291 forceDraw();
292 }
293}
294
295void PainterGL::start() {
296 m_gl->makeCurrent();
297#if defined(_WIN32) && defined(USE_EPOXY)
298 epoxy_handle_external_wglMakeCurrent();
299#endif
300
301#if !defined(_WIN32) || defined(USE_EPOXY)
302 if (m_supportsShaders && m_shader.passes) {
303 mGLES2ShaderAttach(reinterpret_cast<mGLES2Context*>(m_backend), static_cast<mGLES2Shader*>(m_shader.passes), m_shader.nPasses);
304 }
305#endif
306
307 m_gl->doneCurrent();
308 m_active = true;
309 m_started = true;
310}
311
312void PainterGL::draw() {
313 if (m_queue.isEmpty() || !mCoreThreadIsActive(m_context)) {
314 return;
315 }
316 if (mCoreSyncWaitFrameStart(&m_context->sync) || !m_queue.isEmpty()) {
317 dequeue();
318 mCoreSyncWaitFrameEnd(&m_context->sync);
319 m_painter.begin(m_gl->context()->device());
320 performDraw();
321 m_painter.end();
322 m_backend->swap(m_backend);
323 } else {
324 mCoreSyncWaitFrameEnd(&m_context->sync);
325 }
326 if (!m_queue.isEmpty()) {
327 QMetaObject::invokeMethod(this, "draw", Qt::QueuedConnection);
328 }
329}
330
331void PainterGL::forceDraw() {
332 m_painter.begin(m_gl->context()->device());
333 performDraw();
334 m_painter.end();
335 m_backend->swap(m_backend);
336}
337
338void PainterGL::stop() {
339 m_active = false;
340 m_started = false;
341 m_gl->makeCurrent();
342#if defined(_WIN32) && defined(USE_EPOXY)
343 epoxy_handle_external_wglMakeCurrent();
344#endif
345 dequeueAll();
346 m_backend->clear(m_backend);
347 m_backend->swap(m_backend);
348 m_gl->doneCurrent();
349 m_gl->context()->moveToThread(m_gl->thread());
350 moveToThread(m_gl->thread());
351}
352
353void PainterGL::pause() {
354 m_active = false;
355}
356
357void PainterGL::unpause() {
358 m_active = true;
359}
360
361void PainterGL::performDraw() {
362 m_painter.beginNativePainting();
363 float r = m_gl->devicePixelRatio();
364 m_backend->resized(m_backend, m_size.width() * r, m_size.height() * r);
365 m_backend->drawFrame(m_backend);
366 m_painter.endNativePainting();
367 if (m_messagePainter) {
368 m_messagePainter->paint(&m_painter);
369 }
370}
371
372void PainterGL::enqueue(const uint32_t* backing) {
373 m_mutex.lock();
374 uint32_t* buffer;
375 if (m_free.isEmpty()) {
376 buffer = m_queue.dequeue();
377 } else {
378 buffer = m_free.takeLast();
379 }
380 unsigned width, height;
381 m_context->core->desiredVideoDimensions(m_context->core, &width, &height);
382 memcpy(buffer, backing, width * height * BYTES_PER_PIXEL);
383 m_queue.enqueue(buffer);
384 m_mutex.unlock();
385}
386
387void PainterGL::dequeue() {
388 m_mutex.lock();
389 if (m_queue.isEmpty()) {
390 m_mutex.unlock();
391 return;
392 }
393 uint32_t* buffer = m_queue.dequeue();
394 m_backend->postFrame(m_backend, buffer);
395 m_free.append(buffer);
396 m_mutex.unlock();
397}
398
399void PainterGL::dequeueAll() {
400 uint32_t* buffer = 0;
401 m_mutex.lock();
402 while (!m_queue.isEmpty()) {
403 buffer = m_queue.dequeue();
404 m_free.append(buffer);
405 }
406 if (buffer) {
407 m_backend->postFrame(m_backend, buffer);
408 }
409 m_mutex.unlock();
410}
411
412void PainterGL::setShaders(struct VDir* dir) {
413 if (!supportsShaders()) {
414 return;
415 }
416#if !defined(_WIN32) || defined(USE_EPOXY)
417 m_gl->makeCurrent();
418#if defined(_WIN32) && defined(USE_EPOXY)
419 epoxy_handle_external_wglMakeCurrent();
420#endif
421 if (m_shader.passes) {
422 mGLES2ShaderDetach(reinterpret_cast<mGLES2Context*>(m_backend));
423 mGLES2ShaderFree(&m_shader);
424 }
425 mGLES2ShaderLoad(&m_shader, dir);
426 if (m_started) {
427 mGLES2ShaderAttach(reinterpret_cast<mGLES2Context*>(m_backend), static_cast<mGLES2Shader*>(m_shader.passes), m_shader.nPasses);
428 }
429 m_gl->doneCurrent();
430#endif
431}
432
433void PainterGL::clearShaders() {
434 if (!supportsShaders()) {
435 return;
436 }
437#if !defined(_WIN32) || defined(USE_EPOXY)
438 m_gl->makeCurrent();
439#if defined(_WIN32) && defined(USE_EPOXY)
440 epoxy_handle_external_wglMakeCurrent();
441#endif
442 if (m_shader.passes) {
443 mGLES2ShaderDetach(reinterpret_cast<mGLES2Context*>(m_backend));
444 mGLES2ShaderFree(&m_shader);
445 }
446 m_gl->doneCurrent();
447#endif
448}
449
450VideoShader* PainterGL::shaders() {
451 return &m_shader;
452}