1#include "Display.h"
  2
  3#include <QApplication>
  4#include <QResizeEvent>
  5
  6extern "C" {
  7#include "gba-thread.h"
  8}
  9
 10using namespace QGBA;
 11
 12static const GLint _glVertices[] = {
 13	0, 0,
 14	256, 0,
 15	256, 256,
 16	0, 256
 17};
 18
 19static const GLint _glTexCoords[] = {
 20	0, 0,
 21	1, 0,
 22	1, 1,
 23	0, 1
 24};
 25
 26Display::Display(QGLFormat format, QWidget* parent)
 27	: QGLWidget(format, parent)
 28	, m_painter(nullptr)
 29	, m_drawThread(nullptr)
 30{
 31	setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 32	setMinimumSize(VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS);
 33	setAutoBufferSwap(false);
 34	setCursor(Qt::BlankCursor);
 35}
 36
 37void Display::startDrawing(const uint32_t* buffer, GBAThread* thread) {
 38	if (m_drawThread) {
 39		return;
 40	}
 41	m_drawThread = new QThread(this);
 42	m_painter = new Painter(this);
 43	m_painter->setContext(thread);
 44	m_painter->setBacking(buffer);
 45	m_painter->moveToThread(m_drawThread);
 46	m_context = thread;
 47	doneCurrent();
 48	context()->moveToThread(m_drawThread);
 49	connect(m_drawThread, SIGNAL(started()), m_painter, SLOT(start()));
 50	m_drawThread->start(QThread::TimeCriticalPriority);
 51}
 52
 53void Display::stopDrawing() {
 54	if (m_drawThread) {
 55		if (GBAThreadIsActive(m_context)) {
 56			GBAThreadInterrupt(m_context);
 57			GBASyncSuspendDrawing(&m_context->sync);
 58		}
 59		QMetaObject::invokeMethod(m_painter, "stop", Qt::BlockingQueuedConnection);
 60		m_drawThread->exit();
 61		m_drawThread = nullptr;
 62		if (GBAThreadIsActive(m_context)) {
 63			GBASyncResumeDrawing(&m_context->sync);
 64			GBAThreadContinue(m_context);
 65		}
 66	}
 67}
 68
 69void Display::pauseDrawing() {
 70	if (m_drawThread) {
 71		if (GBAThreadIsActive(m_context)) {
 72			GBAThreadInterrupt(m_context);
 73			GBASyncSuspendDrawing(&m_context->sync);
 74		}
 75		QMetaObject::invokeMethod(m_painter, "pause", Qt::BlockingQueuedConnection);
 76		if (GBAThreadIsActive(m_context)) {
 77			GBASyncResumeDrawing(&m_context->sync);
 78			GBAThreadContinue(m_context);
 79		}
 80	}
 81}
 82
 83void Display::unpauseDrawing() {
 84	if (m_drawThread) {
 85		if (GBAThreadIsActive(m_context)) {
 86			GBAThreadInterrupt(m_context);
 87			GBASyncSuspendDrawing(&m_context->sync);
 88		}
 89		QMetaObject::invokeMethod(m_painter, "unpause", Qt::BlockingQueuedConnection);
 90		if (GBAThreadIsActive(m_context)) {
 91			GBASyncResumeDrawing(&m_context->sync);
 92			GBAThreadContinue(m_context);
 93		}
 94	}
 95}
 96
 97void Display::forceDraw() {
 98	if (m_drawThread) {
 99		QMetaObject::invokeMethod(m_painter, "forceDraw", Qt::QueuedConnection);
100	}
101}
102
103#ifdef USE_PNG
104void Display::screenshot() {
105	GBAThreadInterrupt(m_context);
106	GBAThreadTakeScreenshot(m_context);
107	GBAThreadContinue(m_context);
108}
109#endif
110
111void Display::initializeGL() {
112	glClearColor(0, 0, 0, 0);
113	glClear(GL_COLOR_BUFFER_BIT);
114	swapBuffers();
115}
116
117void Display::resizeEvent(QResizeEvent* event) {
118	if (m_drawThread) {
119		GBAThreadInterrupt(m_context);
120		GBASyncSuspendDrawing(&m_context->sync);
121		QMetaObject::invokeMethod(m_painter, "resize", Qt::BlockingQueuedConnection, Q_ARG(QSize, event->size()));
122		GBASyncResumeDrawing(&m_context->sync);
123		GBAThreadContinue(m_context);
124	}
125}
126
127Painter::Painter(Display* parent)
128	: m_gl(parent)
129{
130	m_size = parent->size();
131}
132
133void Painter::setContext(GBAThread* context) {
134	m_context = context;
135}
136
137void Painter::setBacking(const uint32_t* backing) {
138	m_backing = backing;
139}
140
141void Painter::resize(const QSize& size) {
142	m_size = size;
143	m_gl->makeCurrent();
144	glViewport(0, 0, m_size.width() * m_gl->devicePixelRatio(), m_size.height() * m_gl->devicePixelRatio());
145	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
146	m_gl->swapBuffers();
147	m_gl->doneCurrent();
148}
149
150void Painter::start() {
151	m_gl->makeCurrent();
152	glEnable(GL_TEXTURE_2D);
153	glGenTextures(1, &m_tex);
154	glBindTexture(GL_TEXTURE_2D, m_tex);
155	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
156	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
157	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
158	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
159	glEnableClientState(GL_VERTEX_ARRAY);
160	glVertexPointer(2, GL_INT, 0, _glVertices);
161	glTexCoordPointer(2, GL_INT, 0, _glTexCoords);
162	glMatrixMode(GL_PROJECTION);
163	glLoadIdentity();
164	glOrtho(0, 240, 160, 0, 0, 1);
165	glMatrixMode(GL_MODELVIEW);
166	glLoadIdentity();
167	m_gl->doneCurrent();
168
169	m_drawTimer = new QTimer;
170	m_drawTimer->moveToThread(QThread::currentThread());
171	m_drawTimer->setInterval(0);
172	connect(m_drawTimer, SIGNAL(timeout()), this, SLOT(draw()));
173	m_drawTimer->start();
174}
175
176void Painter::draw() {
177	m_gl->makeCurrent();
178	if (GBASyncWaitFrameStart(&m_context->sync, m_context->frameskip)) {
179		glViewport(0, 0, m_size.width() * m_gl->devicePixelRatio(), m_size.height() * m_gl->devicePixelRatio());
180		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_backing);
181		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
182		if (m_context->sync.videoFrameWait) {
183			glFlush();
184		}
185	}
186	GBASyncWaitFrameEnd(&m_context->sync);
187	m_gl->swapBuffers();
188	m_gl->doneCurrent();
189}
190
191void Painter::forceDraw() {
192	m_gl->makeCurrent();
193	glViewport(0, 0, m_size.width() * m_gl->devicePixelRatio(), m_size.height() * m_gl->devicePixelRatio());
194	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_backing);
195	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
196	if (m_context->sync.videoFrameWait) {
197		glFlush();
198	}
199	m_gl->swapBuffers();
200	m_gl->doneCurrent();
201}
202
203void Painter::stop() {
204	m_drawTimer->stop();
205	delete m_drawTimer;
206	m_gl->makeCurrent();
207	glDeleteTextures(1, &m_tex);
208	glClear(GL_COLOR_BUFFER_BIT);
209	m_gl->swapBuffers();
210	m_gl->doneCurrent();
211	m_gl->context()->moveToThread(QApplication::instance()->thread());
212}
213
214void Painter::pause() {
215	m_drawTimer->stop();
216	// Make sure both buffers are filled
217	forceDraw();
218	forceDraw();
219}
220
221void Painter::unpause() {
222	m_drawTimer->start();
223}