@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/src/platform/libretro/memory.c

@@ -0,0 +1,22 @@
+/* Copyright (c) 2013-2020 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/. */
+#include <mgba-util/memory.h>
+
+#ifdef _WIN32
+#include "../windows/memory.c"
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__NetBSD__)
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS 0x20
+#endif
+
+#ifndef MAP_ANON
+#define MAP_ANON MAP_ANONYMOUS
+#endif
+
+#include "../posix/memory.c"
+#else
+#include "../../util/memory.c"
+#endif

package/mgba-bridge/vendor/mgba/src/platform/libretro/retro_inline.h

@@ -0,0 +1,39 @@
+/* Copyright  (C) 2010-2018 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_inline.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_INLINE_H
+#define __LIBRETRO_SDK_INLINE_H
+
+#ifndef INLINE
+
+#if defined(_WIN32) || defined(__INTEL_COMPILER)
+#define INLINE __inline
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
+#define INLINE inline
+#elif defined(__GNUC__)
+#define INLINE __inline__
+#else
+#define INLINE
+#endif
+
+#endif
+#endif

package/mgba-bridge/vendor/mgba/src/platform/opengl/gl.c

@@ -0,0 +1,304 @@
+/* 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/. */
+#include "gl.h"
+
+#include <mgba-util/math.h>
+
+static const GLint _glVertices[] = {
+	0, 0,
+	1, 0,
+	1, 1,
+	0, 1
+};
+
+static const GLint _glTexCoords[] = {
+	0, 0,
+	1, 0,
+	1, 1,
+	0, 1
+};
+
+static inline void _initTex(void) {
+	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+#ifndef _WIN32
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+#endif
+}
+
+static void mGLContextInit(struct VideoBackend* v, WHandle handle) {
+	UNUSED(handle);
+	struct mGLContext* context = (struct mGLContext*) v;
+	memset(context->layerDims, 0, sizeof(context->layerDims));
+	memset(context->imageSizes, -1, sizeof(context->imageSizes));
+	glGenTextures(2, context->tex);
+	glBindTexture(GL_TEXTURE_2D, context->tex[0]);
+	_initTex();
+	glBindTexture(GL_TEXTURE_2D, context->tex[1]);
+	_initTex();
+	context->activeTex = 0;
+
+	glGenTextures(VIDEO_LAYER_MAX, context->layers);
+	int i;
+	for (i = 0; i < VIDEO_LAYER_MAX; ++i) {
+		glBindTexture(GL_TEXTURE_2D, context->layers[i]);
+		_initTex();
+	}
+}
+
+static inline void _setTexDims(int width, int height) {
+#ifdef COLOR_16_BIT
+#ifdef COLOR_5_6_5
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, toPow2(width), toPow2(height), 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0);
+#else
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, toPow2(width), toPow2(height), 0, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0);
+#endif
+#elif defined(__BIG_ENDIAN__)
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, toPow2(width), toPow2(height), 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
+#else
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, toPow2(width), toPow2(height), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+#endif
+}
+
+static void mGLContextSetLayerDimensions(struct VideoBackend* v, enum VideoLayer layer, const struct mRectangle* dims) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	if (layer >= VIDEO_LAYER_MAX) {
+		return;
+	}
+	context->layerDims[layer].x = dims->x;
+	context->layerDims[layer].y = dims->y;
+	if (dims->width == context->layerDims[layer].width && dims->height == context->layerDims[layer].height) {
+		return;
+	}
+	context->layerDims[layer].width = dims->width;
+	context->layerDims[layer].height = dims->height;
+
+	if (context->imageSizes[layer].width <= 0 || context->imageSizes[layer].height <= 0) {
+		if (layer == VIDEO_LAYER_IMAGE) {
+			glBindTexture(GL_TEXTURE_2D, context->tex[0]);
+			_setTexDims(dims->width, dims->height);
+			glBindTexture(GL_TEXTURE_2D, context->tex[1]);
+			_setTexDims(dims->width, dims->height);
+		} else {
+			glBindTexture(GL_TEXTURE_2D, context->layers[layer]);
+			_setTexDims(dims->width, dims->height);
+		}
+	}
+}
+
+static void mGLContextLayerDimensions(const struct VideoBackend* v, enum VideoLayer layer, struct mRectangle* dims) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	if (layer >= VIDEO_LAYER_MAX) {
+		return;
+	}
+	memcpy(dims, &context->layerDims[layer], sizeof(*dims));
+}
+
+static void mGLContextDeinit(struct VideoBackend* v) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	glDeleteTextures(2, context->tex);
+	glDeleteTextures(VIDEO_LAYER_MAX, context->layers);
+}
+
+static void mGLContextResized(struct VideoBackend* v, unsigned w, unsigned h, unsigned maxW, unsigned maxH) {
+	unsigned drawW = w;
+	unsigned drawH = h;
+
+
+	if (maxW && drawW > maxW) {
+		drawW = maxW;
+	}
+
+	if (maxH && drawH > maxH) {
+		drawH = maxH;
+	}
+
+	unsigned lockW;
+	unsigned lockH;
+	VideoBackendGetFrameSize(v, &lockW, &lockH);
+
+	if (v->lockAspectRatio) {
+		lockAspectRatioUInt(lockW, lockH, &drawW, &drawH);
+	}
+	if (v->lockIntegerScaling) {
+		lockIntegerRatioUInt(lockW, &drawW);
+		lockIntegerRatioUInt(lockH, &drawH);
+	}
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+	glClearColor(0, 0, 0, 0);
+	glClear(GL_COLOR_BUFFER_BIT);
+	glViewport((w - drawW) / 2, (h - drawH) / 2, drawW, drawH);
+}
+
+static void mGLContextClear(struct VideoBackend* v) {
+	UNUSED(v);
+	glClearColor(0, 0, 0, 0);
+	glClear(GL_COLOR_BUFFER_BIT);
+}
+
+static void _setFilter(struct VideoBackend* v) {
+	if (v->filter) {
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	} else {
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	}
+}
+
+static void _setFrame(struct mRectangle* dims, struct mRectangle* frame) {
+	GLint viewport[4];
+	glGetIntegerv(GL_VIEWPORT, viewport);
+	glScissor(viewport[0] + (dims->x - frame->x) * viewport[2] / frame->width,
+	          viewport[1] + (frame->height + frame->y - dims->height - dims->y) * viewport[3] / frame->height,
+	          dims->width * viewport[2] / frame->width,
+	          dims->height * viewport[3] / frame->height);
+	glLoadIdentity();
+	glTranslatef(dims->x, dims->y, 0);
+	glScalef(toPow2(dims->width), toPow2(dims->height), 1);
+}
+
+static void _drawLayers(struct mGLContext* context, int start, int end) {
+	struct mRectangle frame;
+	VideoBackendGetFrame(&context->d, &frame);
+
+	int layer;
+	for (layer = start; layer < end; ++layer) {
+		if (context->layerDims[layer].width < 1 || context->layerDims[layer].height < 1) {
+			continue;
+		}
+
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		glBindTexture(GL_TEXTURE_2D, context->layers[layer]);
+		_setFilter(&context->d);
+		_setFrame(&context->layerDims[layer], &frame);
+		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+	}
+}
+
+void mGLContextDrawFrame(struct VideoBackend* v) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	glEnable(GL_TEXTURE_2D);
+	glEnable(GL_SCISSOR_TEST);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glVertexPointer(2, GL_INT, 0, _glVertices);
+	glTexCoordPointer(2, GL_INT, 0, _glTexCoords);
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	struct mRectangle frame;
+	VideoBackendGetFrame(v, &frame);
+	glOrtho(frame.x, frame.x + frame.width, frame.y + frame.height, frame.y, 0, 1);
+	glMatrixMode(GL_MODELVIEW);
+
+	_drawLayers(context, 0, VIDEO_LAYER_IMAGE);
+
+	_setFrame(&context->layerDims[VIDEO_LAYER_IMAGE], &frame);
+	glDisable(GL_BLEND);
+	if (v->interframeBlending) {
+		glBindTexture(GL_TEXTURE_2D, context->tex[context->activeTex ^ 1]);
+		_setFilter(v);
+		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
+		glBlendColor(1, 1, 1, 0.5);
+	}
+
+	glBindTexture(GL_TEXTURE_2D, context->tex[context->activeTex]);
+	_setFilter(v);
+	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+	_drawLayers(context, VIDEO_LAYER_IMAGE + 1, VIDEO_LAYER_MAX);
+}
+
+static void mGLContextSetImageSize(struct VideoBackend* v, enum VideoLayer layer, int width, int height) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	if (layer >= VIDEO_LAYER_MAX) {
+		return;
+	}
+	if (width <= 0 || height <= 0) {
+		context->imageSizes[layer].width = -1;
+		context->imageSizes[layer].height = -1;
+		width = context->layerDims[layer].width;
+		height = context->layerDims[layer].height;
+	} else {
+		context->imageSizes[layer].width = width;
+		context->imageSizes[layer].height = height;
+	}
+	if (layer == VIDEO_LAYER_IMAGE) {
+		glBindTexture(GL_TEXTURE_2D, context->tex[0]);
+		_setTexDims(width, height);
+		glBindTexture(GL_TEXTURE_2D, context->tex[1]);
+		_setTexDims(width, height);
+	} else {
+		glBindTexture(GL_TEXTURE_2D, context->layers[layer]);
+		_setTexDims(width, height);
+	}
+}
+
+static void mGLContextImageSize(struct VideoBackend* v, enum VideoLayer layer, int* width, int* height) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	if (layer >= VIDEO_LAYER_MAX) {
+		return;
+	}
+
+	if (context->imageSizes[layer].width <= 0 || context->imageSizes[layer].height <= 0) {
+		*width = context->layerDims[layer].width;
+		*height = context->layerDims[layer].height;
+	} else {
+		*width = context->imageSizes[layer].width;
+		*height = context->imageSizes[layer].height;
+	}
+}
+
+void mGLContextPostFrame(struct VideoBackend* v, enum VideoLayer layer, const void* frame) {
+	struct mGLContext* context = (struct mGLContext*) v;
+	if (layer >= VIDEO_LAYER_MAX) {
+		return;
+	}
+	if (layer == VIDEO_LAYER_IMAGE) {
+		context->activeTex ^= 1;
+		glBindTexture(GL_TEXTURE_2D, context->tex[context->activeTex]);
+	} else {
+		glBindTexture(GL_TEXTURE_2D, context->layers[layer]);
+	}
+
+	int width = context->imageSizes[layer].width;
+	int height = context->imageSizes[layer].height;
+
+	if (width <= 0 || height <= 0) {
+		width = context->layerDims[layer].width;
+		height = context->layerDims[layer].height;
+	}
+#ifdef COLOR_16_BIT
+#ifdef COLOR_5_6_5
+	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, frame);
+#else
+	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, frame);
+#endif
+#elif defined(__BIG_ENDIAN__)
+	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, frame);
+#else
+	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, frame);
+#endif
+}
+
+void mGLContextCreate(struct mGLContext* context) {
+	context->d.init = mGLContextInit;
+	context->d.deinit = mGLContextDeinit;
+	context->d.setLayerDimensions = mGLContextSetLayerDimensions;
+	context->d.layerDimensions = mGLContextLayerDimensions;
+	context->d.contextResized = mGLContextResized;
+	context->d.swap = NULL;
+	context->d.clear = mGLContextClear;
+	context->d.setImageSize = mGLContextSetImageSize;
+	context->d.imageSize = mGLContextImageSize;
+	context->d.setImage = mGLContextPostFrame;
+	context->d.drawFrame = mGLContextDrawFrame;
+}

package/mgba-bridge/vendor/mgba/src/platform/opengl/gl.h

@@ -0,0 +1,40 @@
+/* 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 GL_H
+#define GL_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#ifdef USE_EPOXY
+#include <epoxy/gl.h>
+#elif defined(__APPLE__)
+#include <OpenGL/gl.h>
+#else
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+#include <GL/gl.h>
+#endif
+
+#include <mgba/feature/video-backend.h>
+
+struct mGLContext {
+	struct VideoBackend d;
+
+	int activeTex;
+	GLuint tex[2];
+	GLuint layers[VIDEO_LAYER_MAX];
+	struct mRectangle layerDims[VIDEO_LAYER_MAX];
+	struct mSize imageSizes[VIDEO_LAYER_MAX];
+};
+
+void mGLContextCreate(struct mGLContext*);
+
+CXX_GUARD_END
+
+#endif