[nostalgia/core] Start port of PC gfx to OpenGL

src/nostalgia/core/userland/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_library(
-	NostalgiaCore-Userspace
+	NostalgiaCore-Userspace OBJECT
+		gfx_opengl.cpp
 		media.cpp
 )
 
@@ -7,10 +8,19 @@ if(NOT MSVC)
 	target_compile_options(NostalgiaCore-Userspace PRIVATE -Wsign-conversion)
 endif()
 
+if(APPLE)
+	find_package(OpenGL REQUIRED)
+else()
+	set(OPENGL_gl_LIBRARY GL)
+endif()
+
 target_link_libraries(
 	NostalgiaCore-Userspace PUBLIC
 		OxFS
 		OxStd
+		NostalgiaCore
+		#GLESv2
+		${OPENGL_gl_LIBRARY}
 )
 
 install(

src/nostalgia/core/userland/gfx.hpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2016 - 2021 gary@drinkingtea.net
+ *
+ * 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/.
+ */
+
+#pragma once
+
+#include <ox/std/types.hpp>
+
+#include <nostalgia/core/context.hpp>
+
+namespace nostalgia::core::renderer {
+
+ox::Error init(Context *ctx);
+
+ox::Error shutdown(Context *ctx);
+
+ox::Error loadTexture(Context *ctx, int section, void *bytes, int w, int h);
+
+}

src/nostalgia/core/userland/gfx_opengl.cpp

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2016 - 2021 gary@drinkingtea.net
+ *
+ * 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 <ox/std/fmt.hpp>
+#define GL_SILENCE_DEPRECATION
+
+#include <array>
+
+#include <ox/std/defines.hpp>
+#include <ox/std/defines.hpp>
+
+#define GL_GLEXT_PROTOTYPES 1
+//#include <GLES2/gl2.h>
+#ifdef OX_OS_Darwin
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include <nostalgia/core/gfx.hpp>
+
+namespace nostalgia::core {
+
+using TileMap = std::array<std::array<int, 128>, 128>;
+
+struct GlImplData {
+	std::array<TileMap, 4> bgTileMaps{};
+	std::array<GLuint, 4> bgTextures{};
+	int64_t prevFpsCheckTime = 0;
+	uint64_t draws = 0;
+};
+
+
+namespace renderer {
+
+ox::Error init(Context *ctx) {
+	const auto id = new GlImplData;
+	ctx->setRendererData(id);
+	return OxError(0);
+}
+
+ox::Error shutdown(Context *ctx) {
+	const auto id = ctx->rendererData<GlImplData>();
+	ctx->setRendererData(nullptr);
+	delete id;
+	return OxError(0);
+}
+
+ox::Error loadTexture(Context *ctx, int section, void *pixels, int w, int h) {
+	oxTracef("nostalgia::core::gfx::gl", "loadTexture: { section: {}, w: {}, h: {} }", section, w, h);
+	const auto &id = ctx->rendererData<GlImplData>();
+	auto &texId = id->bgTextures[static_cast<std::size_t>(section)];
+	glGenTextures(1, &texId);
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, texId);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0,  GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	return OxError(0);
+}
+
+}
+
+
+void draw(Context *ctx) {
+	const auto id = ctx->rendererData<GlImplData>();
+	++id->draws;
+	if (id->draws >= 5000) {
+		using namespace std::chrono;
+		const auto now = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
+		const auto duration = static_cast<double>(now - id->prevFpsCheckTime) / 1000.0;
+		const auto fps = static_cast<int>(static_cast<double>(id->draws) / duration);
+#ifdef NOST_FPS_PRINT
+		std::cout << "FPS: " << fps << '\n';
+#endif
+		oxTracef("nostalgia::core::gfx::gl::fps", "FPS: {}", fps);
+		id->prevFpsCheckTime = now;
+		id->draws = 0;
+	}
+	glClearColor(0, 0, 0, 1);
+	glClear(GL_COLOR_BUFFER_BIT);
+	auto &texId = id->bgTextures[0];
+
+	glEnable(GL_TEXTURE_2D);
+	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+	glBindTexture(GL_TEXTURE_2D, texId);
+
+	// Draw a textured quad
+	glBegin(GL_QUADS);
+	glTexCoord2f(0, 0); glVertex2f(-0.01,  1);
+	glTexCoord2f(0, 1); glVertex2f(-0.01, -1);
+	glTexCoord2f(1, 1); glVertex2f( 0.01, -1);
+	glTexCoord2f(1, 0); glVertex2f( 0.01,  1);
+	glEnd();
+
+	glDisable(GL_TEXTURE_2D);
+
+	for (std::size_t i = 0; i < id->bgTileMaps.size(); i++) {
+	}
+}
+
+void puts(Context *ctx, int column, int row, const char *str) {
+	for (int i = 0; str[i]; ++i) {
+		setTile(ctx, 0, column + i, row, static_cast<uint8_t>(charMap[static_cast<int>(str[i])]));
+	}
+}
+
+void clearTileLayer(Context*, int) {
+}
+
+void hideSprite(Context*, unsigned) {
+}
+
+void setSprite(Context*,
+               unsigned,
+               unsigned,
+               unsigned,
+               unsigned,
+               unsigned,
+               unsigned,
+               unsigned) {
+}
+
+void setTile(Context *ctx, int layer, int column, int row, uint8_t tile) {
+	const auto id = ctx->rendererData<GlImplData>();
+	const auto z = static_cast<unsigned>(layer);
+	const auto y = static_cast<unsigned>(row);
+	const auto x = static_cast<unsigned>(column);
+	id->bgTileMaps[z][y][x] = tile;
+}
+
+}