@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/renderers/gl.h

@@ -0,0 +1,218 @@
+/* Copyright (c) 2013-2019 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef VIDEO_GL_H
+#define VIDEO_GL_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/core/core.h>
+#include <mgba/gba/interface.h>
+#include <mgba/internal/gba/io.h>
+#include <mgba/internal/gba/renderers/common.h>
+#include <mgba/internal/gba/video.h>
+
+#ifdef BUILD_GLES3
+
+#ifdef USE_EPOXY
+#include <epoxy/gl.h>
+#elif defined(__APPLE__)
+#include <OpenGL/gl3.h>
+#elif defined(BUILD_GL)
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#include <GLES3/gl3.h>
+#endif
+
+struct GBAVideoGLAffine {
+	int16_t dx;
+	int16_t dmx;
+	int16_t dy;
+	int16_t dmy;
+	int32_t sx;
+	int32_t sy;
+};
+
+struct GBAVideoGLBackground {
+	GLuint fbo;
+	GLuint tex;
+
+	unsigned index;
+	int enabled;
+	unsigned priority;
+	uint32_t charBase;
+	uint32_t oldCharBase;
+	int mosaic;
+	int multipalette;
+	uint32_t screenBase;
+	int overflow;
+	int size;
+	int target1;
+	int target2;
+	uint16_t x;
+	uint16_t y;
+	int32_t refx;
+	int32_t refy;
+	int32_t offsetX;
+	int32_t offsetY;
+
+	struct GBAVideoGLAffine affine;
+
+	GLint scanlineAffine[GBA_VIDEO_VERTICAL_PIXELS * 4];
+	GLint scanlineOffset[GBA_VIDEO_VERTICAL_PIXELS];
+};
+
+enum {
+	GBA_GL_FBO_OBJ = 0,
+	GBA_GL_FBO_BACKDROP,
+	GBA_GL_FBO_WINDOW,
+	GBA_GL_FBO_OUTPUT,
+	GBA_GL_FBO_MAX
+};
+
+enum {
+	GBA_GL_TEX_OBJ_COLOR = 0,
+	GBA_GL_TEX_OBJ_FLAGS,
+	GBA_GL_TEX_OBJ_DEPTH,
+	GBA_GL_TEX_BACKDROP,
+	GBA_GL_TEX_WINDOW,
+	GBA_GL_TEX_MAX
+};
+
+enum {
+	GBA_GL_VS_LOC = 0,
+	GBA_GL_VS_MAXPOS,
+
+	GBA_GL_BG_VRAM = 2,
+	GBA_GL_BG_PALETTE,
+	GBA_GL_BG_SCREENBASE,
+	GBA_GL_BG_CHARBASE,
+	GBA_GL_BG_SIZE,
+	GBA_GL_BG_OFFSET,
+	GBA_GL_BG_TRANSFORM,
+	GBA_GL_BG_RANGE,
+	GBA_GL_BG_MOSAIC,
+	GBA_GL_BG_OLDCHARBASE,
+
+	GBA_GL_OBJ_VRAM = 2,
+	GBA_GL_OBJ_PALETTE,
+	GBA_GL_OBJ_CHARBASE,
+	GBA_GL_OBJ_TILE,
+	GBA_GL_OBJ_STRIDE,
+	GBA_GL_OBJ_LOCALPALETTE,
+	GBA_GL_OBJ_INFLAGS,
+	GBA_GL_OBJ_TRANSFORM,
+	GBA_GL_OBJ_DIMS,
+	GBA_GL_OBJ_OBJWIN,
+	GBA_GL_OBJ_MOSAIC,
+	GBA_GL_OBJ_CYCLES,
+
+	GBA_GL_WIN_DISPCNT = 2,
+	GBA_GL_WIN_BLEND,
+	GBA_GL_WIN_FLAGS,
+	GBA_GL_WIN_WIN0,
+	GBA_GL_WIN_WIN1,
+	GBA_GL_WIN_CIRCLE0,
+	GBA_GL_WIN_CIRCLE1,
+	GBA_GL_WIN_DISABLE_INTERP,
+
+	GBA_GL_FINALIZE_SCALE = 2,
+	GBA_GL_FINALIZE_LAYERS,
+	GBA_GL_FINALIZE_FLAGS,
+	GBA_GL_FINALIZE_WINDOW,
+	GBA_GL_FINALIZE_PALETTE,
+	GBA_GL_FINALIZE_BACKDROP,
+
+	GBA_GL_UNIFORM_MAX = 14
+};
+
+struct GBAVideoGLShader {
+	GLuint program;
+	GLuint vao;
+	GLuint uniforms[GBA_GL_UNIFORM_MAX];
+};
+
+struct GBAVideoGLRenderer {
+	struct GBAVideoRenderer d;
+
+	uint32_t* temporaryBuffer;
+
+	struct GBAVideoGLBackground bg[4];
+
+	int oamMax;
+	bool oamDirty;
+	struct GBAVideoRendererSprite sprites[128];
+	int16_t objOffsetX;
+	int16_t objOffsetY;
+
+	GLuint fbo[GBA_GL_FBO_MAX];
+	GLuint layers[GBA_GL_TEX_MAX];
+	GLuint vbo;
+
+	GLuint outputTex;
+	bool outputTexDirty;
+
+	GLuint paletteTex;
+	uint16_t shadowPalette[GBA_VIDEO_VERTICAL_PIXELS][512];
+	int nextPalette;
+	int paletteDirtyScanlines;
+	bool paletteDirty;
+
+	GLuint vramTex;
+	unsigned vramDirty;
+
+	uint16_t shadowRegs[0x30];
+	uint64_t regsDirty;
+
+	struct GBAVideoGLShader bgShader[6];
+	struct GBAVideoGLShader objShader[3];
+	struct GBAVideoGLShader windowShader;
+	struct GBAVideoGLShader finalizeShader;
+
+	GBARegisterDISPCNT dispcnt;
+
+	unsigned target1Obj;
+	unsigned target1Bd;
+	unsigned target2Obj;
+	unsigned target2Bd;
+	enum GBAVideoBlendEffect blendEffect;
+	uint16_t blda;
+	uint16_t bldb;
+	uint16_t bldy;
+
+	GBAMosaicControl mosaic;
+
+	struct GBAVideoGLWindowN {
+		struct GBAVideoWindowRegion h;
+		struct GBAVideoWindowRegion v;
+		GBAWindowControl control;
+		int16_t offsetX;
+		int16_t offsetY;
+	} winN[2];
+
+	GLint winNHistory[2][GBA_VIDEO_VERTICAL_PIXELS * 4];
+	GLint spriteCycles[GBA_VIDEO_VERTICAL_PIXELS];
+
+	GBAWindowControl winout;
+	GBAWindowControl objwin;
+
+	int firstAffine;
+	int firstY;
+
+	int scale;
+};
+
+void GBAVideoGLRendererCreate(struct GBAVideoGLRenderer* renderer);
+void GBAVideoGLRendererSetScale(struct GBAVideoGLRenderer* renderer, int scale);
+
+#endif
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/renderers/proxy.h

@@ -0,0 +1,29 @@
+/* Copyright (c) 2013-2017 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_VIDEO_PROXY_H
+#define GBA_VIDEO_PROXY_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/internal/gba/video.h>
+#include <mgba/feature/video-logger.h>
+
+struct GBAVideoProxyRenderer {
+	struct GBAVideoRenderer d;
+	struct GBAVideoRenderer* backend;
+	struct mVideoLogger* logger;
+	int flushScanline;
+};
+
+void GBAVideoProxyRendererCreate(struct GBAVideoProxyRenderer* renderer, struct GBAVideoRenderer* backend, struct mVideoLogger* logger);
+void GBAVideoProxyRendererShim(struct GBAVideo* video, struct GBAVideoProxyRenderer* renderer);
+void GBAVideoProxyRendererUnshim(struct GBAVideo* video, struct GBAVideoProxyRenderer* renderer);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/renderers/video-software.h

@@ -0,0 +1,160 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef VIDEO_SOFTWARE_H
+#define VIDEO_SOFTWARE_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/core/core.h>
+#include <mgba/gba/interface.h>
+#include <mgba/internal/gba/io.h>
+#include <mgba/internal/gba/renderers/common.h>
+#include <mgba/internal/gba/video.h>
+
+struct GBAVideoSoftwareBackground {
+	unsigned index;
+	int enabled;
+	unsigned priority;
+	uint32_t charBase;
+	int mosaic;
+	int multipalette;
+	uint32_t screenBase;
+	int overflow;
+	int size;
+	int target1;
+	int target2;
+	uint16_t x;
+	uint16_t y;
+	int32_t refx;
+	int32_t refy;
+	int16_t dx;
+	int16_t dmx;
+	int16_t dy;
+	int16_t dmy;
+	int32_t sx;
+	int32_t sy;
+	int yCache;
+	uint16_t mapCache[64];
+	uint32_t flags;
+	uint32_t objwinFlags;
+	int objwinForceEnable;
+	bool objwinOnly;
+	bool variant;
+	int32_t offsetX;
+	int32_t offsetY;
+	bool highlight;
+};
+
+enum {
+	OFFSET_PRIORITY = 30,
+	OFFSET_INDEX = 28,
+};
+
+#define FLAG_PRIORITY       0xC0000000
+#define FLAG_INDEX          0x30000000
+#define FLAG_IS_BACKGROUND  0x08000000
+#define FLAG_UNWRITTEN      0xFC000000
+#define FLAG_REBLEND        0x04000000
+#define FLAG_TARGET_1       0x02000000
+#define FLAG_TARGET_2       0x01000000
+#define FLAG_OBJWIN         0x01000000
+#define FLAG_ORDER_MASK     0xF8000000
+
+#define IS_WRITABLE(PIXEL) ((PIXEL) & 0xFE000000)
+
+struct WindowControl {
+	GBAWindowControl packed;
+	int8_t priority;
+};
+
+#define MAX_WINDOW 5
+
+struct Window {
+	uint8_t endX;
+	struct WindowControl control;
+};
+
+struct GBAVideoSoftwareRenderer {
+	struct GBAVideoRenderer d;
+
+	mColor* outputBuffer;
+	int outputBufferStride;
+
+	uint32_t* temporaryBuffer;
+
+	GBARegisterDISPCNT dispcnt;
+
+	uint32_t row[GBA_VIDEO_HORIZONTAL_PIXELS];
+	uint32_t spriteLayer[GBA_VIDEO_HORIZONTAL_PIXELS];
+	int32_t spriteCyclesRemaining;
+
+	// BLDCNT
+	unsigned target1Obj;
+	unsigned target1Bd;
+	unsigned target2Obj;
+	unsigned target2Bd;
+	bool blendDirty;
+	enum GBAVideoBlendEffect blendEffect;
+	mColor normalPalette[512];
+	mColor variantPalette[512];
+	mColor highlightPalette[512];
+	mColor highlightVariantPalette[512];
+
+	uint16_t blda;
+	uint16_t bldb;
+	uint16_t bldy;
+
+	GBAMosaicControl mosaic;
+	bool stereo;
+
+	struct WindowN {
+		struct GBAVideoWindowRegion h;
+		struct GBAVideoWindowRegion v;
+		struct WindowControl control;
+		int16_t offsetX;
+		int16_t offsetY;
+		bool on;
+	} winN[2];
+
+	struct WindowControl winout;
+	struct WindowControl objwin;
+
+	struct WindowControl currentWindow;
+
+	int nWindows;
+	struct Window windows[MAX_WINDOW];
+
+	struct GBAVideoSoftwareBackground bg[4];
+
+	bool forceTarget1;
+	bool oamDirty;
+	int oamMax;
+	struct GBAVideoRendererSprite sprites[128];
+	int16_t objOffsetX;
+	int16_t objOffsetY;
+
+	uint32_t scanlineDirty[5];
+	uint16_t nextIo[GBA_REG(SOUND1CNT_LO)];
+	struct ScanlineCache {
+		uint16_t io[GBA_REG(SOUND1CNT_LO)];
+		int32_t scale[2][2];
+		bool windowOn[2];
+	} cache[GBA_VIDEO_VERTICAL_PIXELS];
+	int nextY;
+
+	int start;
+	int end;
+
+	uint8_t lastHighlightAmount;
+};
+
+void GBAVideoSoftwareRendererCreate(struct GBAVideoSoftwareRenderer* renderer);
+
+CXX_GUARD_START
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/savedata.h

@@ -0,0 +1,130 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_SAVEDATA_H
+#define GBA_SAVEDATA_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/core/log.h>
+#include <mgba/core/timing.h>
+#include <mgba/gba/interface.h>
+
+mLOG_DECLARE_CATEGORY(GBA_SAVE);
+
+struct VFile;
+
+enum SavedataCommand {
+	EEPROM_COMMAND_NULL = 0,
+	EEPROM_COMMAND_PENDING = 1,
+	EEPROM_COMMAND_WRITE = 2,
+	EEPROM_COMMAND_READ_PENDING = 3,
+	EEPROM_COMMAND_READ = 4,
+
+	FLASH_COMMAND_START = 0xAA,
+	FLASH_COMMAND_CONTINUE = 0x55,
+
+	FLASH_COMMAND_ERASE_CHIP = 0x10,
+	FLASH_COMMAND_ERASE_SECTOR = 0x30,
+
+	FLASH_COMMAND_NONE = 0,
+	FLASH_COMMAND_ERASE = 0x80,
+	FLASH_COMMAND_ID = 0x90,
+	FLASH_COMMAND_PROGRAM = 0xA0,
+	FLASH_COMMAND_SWITCH_BANK = 0xB0,
+	FLASH_COMMAND_TERMINATE = 0xF0
+};
+
+enum FlashStateMachine {
+	FLASH_STATE_RAW = 0,
+	FLASH_STATE_START = 1,
+	FLASH_STATE_CONTINUE = 2,
+};
+
+enum FlashId {
+	FLASH_ATMEL_AT29LV512 = 0x3D1F, // 512k
+	FLASH_MACRONIX_MX29L512 = 0x1CC2, // 512k, unused
+	FLASH_MACRONIX_MX29L010 = 0x09C2, // 1M
+	FLASH_PANASONIC_MN63F805MNP = 0x1B32, // 512k, unused
+	FLASH_SANYO_LE26FV10N1TS = 0x1362, // 1M
+	FLASH_SST_39LVF512 = 0xD4BF, // 512k
+};
+
+enum {
+	SAVEDATA_FLASH_BASE = 0x0E005555,
+
+	FLASH_BASE_HI = 0x5555,
+	FLASH_BASE_LO = 0x2AAA
+};
+
+struct GBASavedata {
+	enum GBASavedataType type;
+	uint8_t* data;
+	enum SavedataCommand command;
+	struct VFile* vf;
+	struct GBACartridgeHardware* gpio;
+
+	int mapMode;
+	bool maskWriteback;
+	struct VFile* realVf;
+
+	int8_t readBitsRemaining;
+	uint32_t readAddress;
+	uint32_t writeAddress;
+
+	uint8_t* currentBank;
+
+	struct mTiming* timing;
+	unsigned settling;
+	struct mTimingEvent dust;
+
+	int dirty;
+	uint32_t dirtAge;
+
+	enum FlashStateMachine flashState;
+};
+
+struct GBASavedataRTCBuffer {
+	uint8_t time[7];
+	uint8_t control;
+	uint64_t lastLatch;
+};
+
+void GBASavedataInit(struct GBASavedata* savedata, struct VFile* vf);
+void GBASavedataReset(struct GBASavedata* savedata);
+void GBASavedataDeinit(struct GBASavedata* savedata);
+
+void GBASavedataMask(struct GBASavedata* savedata, struct VFile* vf, bool writeback);
+void GBASavedataUnmask(struct GBASavedata* savedata);
+size_t GBASavedataSize(const struct GBASavedata* savedata);
+bool GBASavedataClone(struct GBASavedata* savedata, struct VFile* out);
+bool GBASavedataLoad(struct GBASavedata* savedata, struct VFile* in);
+void GBASavedataForceType(struct GBASavedata* savedata, enum GBASavedataType type);
+
+void GBASavedataInitFlash(struct GBASavedata* savedata);
+void GBASavedataInitEEPROM(struct GBASavedata* savedata);
+void GBASavedataInitSRAM(struct GBASavedata* savedata);
+void GBASavedataInitSRAM512(struct GBASavedata* savedata);
+
+uint8_t GBASavedataReadFlash(struct GBASavedata* savedata, uint16_t address);
+void GBASavedataWriteFlash(struct GBASavedata* savedata, uint16_t address, uint8_t value);
+
+uint16_t GBASavedataReadEEPROM(struct GBASavedata* savedata);
+void GBASavedataWriteEEPROM(struct GBASavedata* savedata, uint16_t value, uint32_t writeSize);
+
+void GBASavedataClean(struct GBASavedata* savedata, uint32_t frameCount);
+
+void GBASavedataRTCRead(struct GBASavedata* savedata);
+void GBASavedataRTCWrite(struct GBASavedata* savedata);
+
+struct GBASerializedState;
+void GBASavedataSerialize(const struct GBASavedata* savedata, struct GBASerializedState* state);
+void GBASavedataDeserialize(struct GBASavedata* savedata, const struct GBASerializedState* state);
+
+CXX_GUARD_END
+
+#endif