all repos — mgba @ fc905657adeba406a2c280bbb94b09533a89e3f8

mGBA Game Boy Advance Emulator

src/platform/qt/GameController.h (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#ifndef QGBA_GAME_CONTROLLER
  7#define QGBA_GAME_CONTROLLER
  8
  9#include <QAtomicInt>
 10#include <QFile>
 11#include <QImage>
 12#include <QObject>
 13#include <QString>
 14#include <QTimer>
 15
 16#include <memory>
 17
 18extern "C" {
 19#include "gba/cheats.h"
 20#include "gba/hardware.h"
 21#include "gba/supervisor/thread.h"
 22#ifdef BUILD_SDL
 23#include "sdl-events.h"
 24#endif
 25}
 26
 27struct GBAAudio;
 28struct mCoreOptions;
 29struct GBAVideoSoftwareRenderer;
 30struct Configuration;
 31
 32class QThread;
 33
 34namespace QGBA {
 35
 36class AudioProcessor;
 37class InputController;
 38class MultiplayerController;
 39
 40class GameController : public QObject {
 41Q_OBJECT
 42
 43public:
 44	static const bool VIDEO_SYNC = false;
 45	static const bool AUDIO_SYNC = true;
 46
 47	GameController(QObject* parent = nullptr);
 48	~GameController();
 49
 50	const uint32_t* drawContext() const { return m_drawContext; }
 51	GBAThread* thread() { return &m_threadContext; }
 52	GBACheatDevice* cheatDevice() { return &m_cheatDevice; }
 53
 54	void threadInterrupt();
 55	void threadContinue();
 56
 57	bool isPaused();
 58	bool isLoaded() { return m_gameOpen && GBAThreadIsActive(&m_threadContext); }
 59
 60	bool audioSync() const { return m_audioSync; }
 61	bool videoSync() const { return m_videoSync; }
 62
 63	void setInputController(InputController* controller) { m_inputController = controller; }
 64	void setOverrides(Configuration* overrides) { m_threadContext.overrides = overrides; }
 65
 66	void setMultiplayerController(MultiplayerController* controller);
 67	MultiplayerController* multiplayerController() { return m_multiplayer; }
 68	void clearMultiplayerController();
 69
 70	void setOverride(const GBACartridgeOverride& override);
 71	void clearOverride() { m_threadContext.hasOverride = false; }
 72
 73	void setOptions(const mCoreOptions*);
 74
 75	int stateSlot() const { return m_stateSlot; }
 76
 77#ifdef USE_GDB_STUB
 78	Debugger* debugger();
 79	void setDebugger(Debugger*);
 80#endif
 81
 82signals:
 83	void frameAvailable(const uint32_t*);
 84	void gameStarted(GBAThread*);
 85	void gameStopped(GBAThread*);
 86	void gamePaused(GBAThread*);
 87	void gameUnpaused(GBAThread*);
 88	void gameCrashed(const QString& errorMessage);
 89	void gameFailed();
 90	void stateLoaded(GBAThread*);
 91	void rewound(GBAThread*);
 92	void unimplementedBiosCall(int);
 93
 94	void luminanceValueChanged(int);
 95
 96	void statusPosted(const QString& message);
 97	void postLog(int level, const QString& log);
 98
 99public slots:
100	void loadGame(const QString& path);
101	void loadBIOS(const QString& path);
102	void yankPak();
103	void replaceGame(const QString& path);
104	void setSkipBIOS(bool);
105	void setUseBIOS(bool);
106	void loadPatch(const QString& path);
107	void importSharkport(const QString& path);
108	void exportSharkport(const QString& path);
109	void bootBIOS();
110	void closeGame();
111	void setPaused(bool paused);
112	void reset();
113	void frameAdvance();
114	void setRewind(bool enable, int capacity, int interval);
115	void rewind(int states = 0);
116	void startRewinding();
117	void stopRewinding();
118	void keyPressed(int key);
119	void keyReleased(int key);
120	void clearKeys();
121	void setAutofire(int key, bool enable);
122	void setAudioBufferSamples(int samples);
123	void setAudioSampleRate(unsigned rate);
124	void setAudioChannelEnabled(int channel, bool enable = true);
125	void startAudio();
126	void setVideoLayerEnabled(int layer, bool enable = true);
127	void setFPSTarget(float fps);
128	void loadState(int slot = 0);
129	void saveState(int slot = 0);
130	void loadBackupState();
131	void saveBackupState();
132	void setVideoSync(bool);
133	void setAudioSync(bool);
134	void setFrameskip(int);
135	void setVolume(int);
136	void setMute(bool);
137	void setTurbo(bool, bool forced = true);
138	void setTurboSpeed(float ratio = -1);
139	void setAVStream(mAVStream*);
140	void clearAVStream();
141	void reloadAudioDriver();
142	void setSaveStateExtdata(int flags);
143	void setLoadStateExtdata(int flags);
144
145#ifdef USE_PNG
146	void screenshot();
147#endif
148
149	void setLuminanceValue(uint8_t value);
150	uint8_t luminanceValue() const { return m_luxValue; }
151	void setLuminanceLevel(int level);
152	void increaseLuminanceLevel() { setLuminanceLevel(m_luxLevel + 1); }
153	void decreaseLuminanceLevel() { setLuminanceLevel(m_luxLevel - 1); }
154
155	void setRealTime();
156	void setFixedTime(const QDateTime& time);
157	void setFakeEpoch(const QDateTime& time);
158
159	void setLogLevel(int);
160	void enableLogLevel(int);
161	void disableLogLevel(int);
162
163private slots:
164	void openGame(bool bios = false);
165	void crashGame(const QString& crashMessage);
166
167	void pollEvents();
168	void updateAutofire();
169
170private:
171	void updateKeys();
172	void redoSamples(int samples);
173	void enableTurbo();
174
175	uint32_t* m_drawContext;
176	uint32_t* m_frontBuffer;
177	GBAThread m_threadContext;
178	GBAVideoSoftwareRenderer* m_renderer;
179	GBACheatDevice m_cheatDevice;
180	int m_activeKeys;
181	int m_activeButtons;
182	int m_inactiveKeys;
183	int m_logLevels;
184
185	bool m_gameOpen;
186
187	QString m_fname;
188	QString m_bios;
189	bool m_useBios;
190	QString m_patch;
191
192	QThread* m_audioThread;
193	AudioProcessor* m_audioProcessor;
194
195	QAtomicInt m_pauseAfterFrame;
196
197	bool m_videoSync;
198	bool m_audioSync;
199	float m_fpsTarget;
200	bool m_turbo;
201	bool m_turboForced;
202	float m_turboSpeed;
203	QTimer m_rewindTimer;
204	bool m_wasPaused;
205
206	bool m_audioChannels[6];
207	bool m_videoLayers[5];
208
209	bool m_autofire[GBA_KEY_MAX];
210	int m_autofireStatus[GBA_KEY_MAX];
211
212	int m_stateSlot;
213	GBASerializedState* m_backupLoadState;
214	QByteArray m_backupSaveState;
215	int m_saveStateFlags;
216	int m_loadStateFlags;
217
218	InputController* m_inputController;
219	MultiplayerController* m_multiplayer;
220
221	struct GameControllerLux : GBALuminanceSource {
222		GameController* p;
223		uint8_t value;
224	} m_lux;
225	uint8_t m_luxValue;
226	int m_luxLevel;
227
228	GBARTCGenericSource m_rtc;
229};
230
231}
232
233#endif