Merge branch 'master' of github.com:isledecomp/isle-portable into webgl

.github/workflows/ci.yml

@@ -66,7 +66,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y \
             libx11-dev libxext-dev libxrandr-dev libxrender-dev libxfixes-dev libxi-dev libxinerama-dev \
-            libxcursor-dev libwayland-dev libxkbcommon-dev wayland-protocols libgl1-mesa-dev libglew-dev qt6-base-dev \
+            libxcursor-dev libwayland-dev libxkbcommon-dev wayland-protocols libgl1-mesa-dev qt6-base-dev \
             libasound2-dev
 
       - name: Install macOS dependencies (brew)

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y \
             libx11-dev libxext-dev libxrandr-dev libxrender-dev libxfixes-dev libxi-dev libxinerama-dev \
-            libxcursor-dev libwayland-dev libxkbcommon-dev wayland-protocols libgl1-mesa-dev libglew-dev qt6-base-dev \
+            libxcursor-dev libwayland-dev libxkbcommon-dev wayland-protocols libgl1-mesa-dev qt6-base-dev \
             libasound2-dev
 
       - name: Install macOS dependencies (brew)

ISLE/isleapp.cpp

@@ -657,6 +657,7 @@ MxResult IsleApp::SetupWindow()
 #ifdef MINIWIN
 	SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN, true);
 	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 #endif
 
 	window = SDL_CreateWindowWithProperties(props);

miniwin/CMakeLists.txt

@@ -32,14 +32,16 @@ target_compile_definitions(miniwin PRIVATE
 )
 
 find_package(OpenGL)
-find_package(GLEW)
+if(OpenGL_FOUND)
-if(OpenGL_FOUND AND GLEW_FOUND)
+  message(STATUS "Found OpenGL: enabling OpenGL 1.x renderer")
-  message(STATUS "Found OpenGL and GLEW: enabling OpenGL 1.x renderer")
+  target_sources(miniwin PRIVATE
-  target_sources(miniwin PRIVATE src/d3drm/backends/opengl1/renderer.cpp)
+    src/d3drm/backends/opengl1/actual.cpp
+    src/d3drm/backends/opengl1/renderer.cpp
+  )
   target_compile_definitions(miniwin PRIVATE USE_OPENGL1)
-  target_link_libraries(miniwin PRIVATE OpenGL::GL GLEW::GLEW)
+  target_link_libraries(miniwin PRIVATE OpenGL::GL)
 else()
-  message(STATUS "🧩 OpenGL 1.x support not enabled — needs OpenGL and GLEW")
+  message(STATUS "🧩 OpenGL 1.x support not enabled — needs OpenGL")
 endif()
 
 if(EMSCRIPTEN)

miniwin/src/d3drm/backends/opengl1/actual.cpp

@@ -0,0 +1,354 @@
+// This file cannot include any minwin headers.
+
+#include "actual.h"
+
+#include "structs.h"
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_opengl.h>
+#include <algorithm>
+#include <cstring>
+#include <vector>
+
+// GL extension API functions.
+bool g_useVBOs;
+PFNGLGENBUFFERSPROC mwglGenBuffers;
+PFNGLBINDBUFFERPROC mwglBindBuffer;
+PFNGLBUFFERDATAPROC mwglBufferData;
+PFNGLDELETEBUFFERSPROC mwglDeleteBuffers;
+
+void GL11_InitState()
+{
+	glEnable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
+	glFrontFace(GL_CW);
+}
+
+void GL11_LoadExtensions()
+{
+	g_useVBOs = SDL_GL_ExtensionSupported("GL_ARB_vertex_buffer_object");
+
+	if (g_useVBOs) {
+		// Load the required GL function pointers.
+		mwglGenBuffers = (PFNGLGENBUFFERSPROC) SDL_GL_GetProcAddress("glGenBuffersARB");
+		mwglBindBuffer = (PFNGLBINDBUFFERPROC) SDL_GL_GetProcAddress("glBindBufferARB");
+		mwglBufferData = (PFNGLBUFFERDATAPROC) SDL_GL_GetProcAddress("glBufferDataARB");
+		mwglDeleteBuffers = (PFNGLDELETEBUFFERSPROC) SDL_GL_GetProcAddress("glDeleteBuffersARB");
+	}
+}
+
+void GL11_DestroyTexture(GLuint texId)
+{
+	glDeleteTextures(1, &texId);
+}
+
+GLuint GL11_UploadTextureData(void* pixels, int width, int height)
+{
+	GLuint texId;
+	glGenTextures(1, &texId);
+	glBindTexture(GL_TEXTURE_2D, texId);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+	return texId;
+}
+
+void GL11_UploadMesh(GLMeshCacheEntry& cache, bool hasTexture)
+{
+	if (g_useVBOs) {
+		mwglGenBuffers(1, &cache.vboPositions);
+		mwglBindBuffer(GL_ARRAY_BUFFER_ARB, cache.vboPositions);
+		mwglBufferData(
+			GL_ARRAY_BUFFER_ARB,
+			cache.positions.size() * sizeof(GL11_BridgeVector),
+			cache.positions.data(),
+			GL_STATIC_DRAW_ARB
+		);
+
+		mwglGenBuffers(1, &cache.vboNormals);
+		mwglBindBuffer(GL_ARRAY_BUFFER_ARB, cache.vboNormals);
+		mwglBufferData(
+			GL_ARRAY_BUFFER_ARB,
+			cache.normals.size() * sizeof(GL11_BridgeVector),
+			cache.normals.data(),
+			GL_STATIC_DRAW_ARB
+		);
+
+		if (hasTexture) {
+			mwglGenBuffers(1, &cache.vboTexcoords);
+			mwglBindBuffer(GL_ARRAY_BUFFER_ARB, cache.vboTexcoords);
+			mwglBufferData(
+				GL_ARRAY_BUFFER_ARB,
+				cache.texcoords.size() * sizeof(GL11_BridgeTexCoord),
+				cache.texcoords.data(),
+				GL_STATIC_DRAW_ARB
+			);
+		}
+
+		mwglGenBuffers(1, &cache.ibo);
+		mwglBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, cache.ibo);
+		mwglBufferData(
+			GL_ELEMENT_ARRAY_BUFFER_ARB,
+			cache.indices.size() * sizeof(cache.indices[0]),
+			cache.indices.data(),
+			GL_STATIC_DRAW_ARB
+		);
+	}
+}
+
+void GL11_DestroyMesh(GLMeshCacheEntry& cache)
+{
+	if (g_useVBOs) {
+		mwglDeleteBuffers(1, &cache.vboPositions);
+		mwglDeleteBuffers(1, &cache.vboNormals);
+		mwglDeleteBuffers(1, &cache.vboTexcoords);
+		mwglDeleteBuffers(1, &cache.ibo);
+	}
+}
+
+void GL11_BeginFrame(const Matrix4x4* projection)
+{
+	glDisable(GL_BLEND);
+	glEnable(GL_DEPTH_TEST);
+	glDepthMask(GL_TRUE);
+	glEnable(GL_LIGHTING);
+	glEnable(GL_COLOR_MATERIAL);
+	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
+
+	// Disable all lights and reset global ambient
+	for (int i = 0; i < 8; ++i) {
+		glDisable(GL_LIGHT0 + i);
+	}
+	const GLfloat zeroAmbient[4] = {0.f, 0.f, 0.f, 1.f};
+	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, zeroAmbient);
+	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
+
+	// Projection and view
+	glMatrixMode(GL_PROJECTION);
+	glLoadMatrixf((const GLfloat*) projection);
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+}
+
+void GL11_UploadLight(int lightIdx, GL11_BridgeSceneLight* l)
+{
+	// Setup light
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadIdentity();
+	GLenum lightId = GL_LIGHT0 + lightIdx++;
+	const FColor& c = l->color;
+	GLfloat col[4] = {c.r, c.g, c.b, c.a};
+	const GLfloat zeroAmbient[4] = {0.f, 0.f, 0.f, 1.f};
+
+	if (l->positional == 0.f && l->directional == 0.f) {
+		// Ambient light only
+		glLightfv(lightId, GL_AMBIENT, col);
+		const GLfloat black[4] = {0.f, 0.f, 0.f, 1.f};
+		glLightfv(lightId, GL_DIFFUSE, black);
+		glLightfv(lightId, GL_SPECULAR, black);
+		const GLfloat dummyPos[4] = {0.f, 0.f, 1.f, 0.f};
+		glLightfv(lightId, GL_POSITION, dummyPos);
+	}
+	else {
+		glLightfv(lightId, GL_AMBIENT, zeroAmbient);
+		glLightfv(lightId, GL_DIFFUSE, col);
+		if (l->directional == 1.0f) {
+			glLightfv(lightId, GL_SPECULAR, col);
+		}
+		else {
+			const GLfloat black[4] = {0.f, 0.f, 0.f, 1.f};
+			glLightfv(lightId, GL_SPECULAR, black);
+		}
+
+		GLfloat pos[4];
+		if (l->directional == 1.f) {
+			pos[0] = -l->direction.x;
+			pos[1] = -l->direction.y;
+			pos[2] = -l->direction.z;
+			pos[3] = 0.f;
+		}
+		else {
+			pos[0] = l->position.x;
+			pos[1] = l->position.y;
+			pos[2] = l->position.z;
+			pos[3] = 1.f;
+		}
+		glLightfv(lightId, GL_POSITION, pos);
+	}
+	glEnable(lightId);
+
+	glPopMatrix();
+}
+
+void GL11_EnableTransparency()
+{
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glDepthMask(GL_FALSE);
+}
+
+#define NO_TEXTURE_ID 0xffffffff
+
+void GL11_SubmitDraw(
+	GLMeshCacheEntry& mesh,
+	const Matrix4x4& modelViewMatrix,
+	const Appearance& appearance,
+	GLuint texId
+)
+{
+	glLoadMatrixf(&modelViewMatrix[0][0]);
+	glEnable(GL_NORMALIZE);
+
+	glColor4ub(appearance.color.r, appearance.color.g, appearance.color.b, appearance.color.a);
+
+	if (appearance.shininess != 0.0f) {
+		GLfloat whiteSpec[] = {1.f, 1.f, 1.f, 1.f};
+		glMaterialfv(GL_FRONT, GL_SPECULAR, whiteSpec);
+		glMaterialf(GL_FRONT, GL_SHININESS, appearance.shininess);
+	}
+	else {
+		GLfloat noSpec[] = {0.0f, 0.0f, 0.0f, 0.0f};
+		glMaterialfv(GL_FRONT, GL_SPECULAR, noSpec);
+		glMaterialf(GL_FRONT, GL_SHININESS, 0.0f);
+	}
+
+	if (mesh.flat) {
+		glShadeModel(GL_FLAT);
+	}
+	else {
+		glShadeModel(GL_SMOOTH);
+	}
+
+	// Bind texture if present
+	if (appearance.textureId != NO_TEXTURE_ID) {
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glEnable(GL_TEXTURE_2D);
+		glBindTexture(GL_TEXTURE_2D, texId);
+		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	}
+	else {
+		glDisable(GL_TEXTURE_2D);
+		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	}
+
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_NORMAL_ARRAY);
+
+	if (g_useVBOs) {
+		mwglBindBuffer(GL_ARRAY_BUFFER_ARB, mesh.vboPositions);
+		glVertexPointer(3, GL_FLOAT, 0, nullptr);
+
+		mwglBindBuffer(GL_ARRAY_BUFFER_ARB, mesh.vboNormals);
+		glNormalPointer(GL_FLOAT, 0, nullptr);
+
+		if (appearance.textureId != NO_TEXTURE_ID) {
+			mwglBindBuffer(GL_ARRAY_BUFFER_ARB, mesh.vboTexcoords);
+			glTexCoordPointer(2, GL_FLOAT, 0, nullptr);
+		}
+
+		mwglBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, mesh.ibo);
+		glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(mesh.indices.size()), GL_UNSIGNED_SHORT, nullptr);
+
+		mwglBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
+		mwglBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
+	}
+	else {
+		glVertexPointer(3, GL_FLOAT, 0, mesh.positions.data());
+		glNormalPointer(GL_FLOAT, 0, mesh.normals.data());
+		if (appearance.textureId != NO_TEXTURE_ID) {
+			glTexCoordPointer(2, GL_FLOAT, 0, mesh.texcoords.data());
+		}
+
+		glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(mesh.indices.size()), GL_UNSIGNED_SHORT, mesh.indices.data());
+	}
+
+	glPopMatrix();
+}
+
+void GL11_Resize(int width, int height)
+{
+	glViewport(0, 0, width, height);
+}
+
+void GL11_Clear(float r, float g, float b)
+{
+	glEnable(GL_DEPTH_TEST);
+	glDepthMask(GL_TRUE);
+	glClearColor(r, g, b, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void GL11_Draw2DImage(
+	GLuint texId,
+	const SDL_Rect& srcRect,
+	const SDL_Rect& dstRect,
+	float left,
+	float right,
+	float bottom,
+	float top
+)
+{
+	glDisable(GL_DEPTH_TEST);
+	glDepthMask(GL_FALSE);
+
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glLoadIdentity();
+
+	glOrtho(left, right, bottom, top, -1, 1);
+
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadIdentity();
+
+	glDisable(GL_LIGHTING);
+	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+
+	glEnable(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, texId);
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	GLint boundTexture = 0;
+	glGetIntegerv(GL_TEXTURE_BINDING_2D, &boundTexture);
+
+	GLfloat texW, texH;
+	glGetTexLevelParameterfv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &texW);
+	glGetTexLevelParameterfv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &texH);
+
+	float u1 = srcRect.x / texW;
+	float v1 = srcRect.y / texH;
+	float u2 = (srcRect.x + srcRect.w) / texW;
+	float v2 = (srcRect.y + srcRect.h) / texH;
+
+	float x1 = (float) dstRect.x;
+	float y1 = (float) dstRect.y;
+	float x2 = x1 + dstRect.w;
+	float y2 = y1 + dstRect.h;
+
+	glBegin(GL_QUADS);
+	glTexCoord2f(u1, v1);
+	glVertex2f(x1, y1);
+	glTexCoord2f(u2, v1);
+	glVertex2f(x2, y1);
+	glTexCoord2f(u2, v2);
+	glVertex2f(x2, y2);
+	glTexCoord2f(u1, v2);
+	glVertex2f(x1, y2);
+	glEnd();
+
+	// Restore state
+	glMatrixMode(GL_MODELVIEW);
+	glPopMatrix();
+	glMatrixMode(GL_PROJECTION);
+	glPopMatrix();
+}
+
+void GL11_Download(SDL_Surface* target)
+{
+	glFinish();
+	glReadPixels(0, 0, target->w, target->h, GL_RGBA, GL_UNSIGNED_BYTE, target->pixels);
+}

miniwin/src/d3drm/backends/opengl1/actual.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "structs.h"
+
+#include <SDL3/SDL.h>
+#include <stdint.h>
+#include <vector>
+
+// We don't want to transitively include windows.h, but we need GLuint
+typedef unsigned int GLuint;
+struct IDirect3DRMTexture;
+struct MeshGroup;
+
+typedef float Matrix4x4[4][4];
+
+struct GL11_BridgeVector {
+	float x, y, z;
+};
+
+struct GL11_BridgeTexCoord {
+	float u, v;
+};
+
+struct GL11_BridgeSceneLight {
+	FColor color;
+	GL11_BridgeVector position;
+	float positional;
+	GL11_BridgeVector direction;
+	float directional;
+};
+
+struct GL11_BridgeSceneVertex {
+	GL11_BridgeVector position;
+	GL11_BridgeVector normal;
+	float tu, tv;
+};
+
+struct GLTextureCacheEntry {
+	IDirect3DRMTexture* texture;
+	Uint32 version;
+	GLuint glTextureId;
+};
+
+struct GLMeshCacheEntry {
+	const MeshGroup* meshGroup;
+	int version;
+	bool flat;
+
+	// non-VBO cache
+	std::vector<GL11_BridgeVector> positions;
+	std::vector<GL11_BridgeVector> normals;
+	std::vector<GL11_BridgeTexCoord> texcoords;
+	std::vector<uint16_t> indices;
+
+	// VBO cache
+	GLuint vboPositions;
+	GLuint vboNormals;
+	GLuint vboTexcoords;
+	GLuint ibo;
+};
+
+void GL11_InitState();
+void GL11_LoadExtensions();
+void GL11_DestroyTexture(GLuint texId);
+GLuint GL11_UploadTextureData(void* pixels, int width, int height);
+void GL11_UploadMesh(GLMeshCacheEntry& cache, bool hasTexture);
+void GL11_DestroyMesh(GLMeshCacheEntry& cache);
+void GL11_BeginFrame(const Matrix4x4* projection);
+void GL11_UploadLight(int lightIdx, GL11_BridgeSceneLight* l);
+void GL11_EnableTransparency();
+void GL11_SubmitDraw(
+	GLMeshCacheEntry& mesh,
+	const Matrix4x4& modelViewMatrix,
+	const Appearance& appearance,
+	GLuint texId
+);
+void GL11_Resize(int width, int height);
+void GL11_Clear(float r, float g, float b);
+void GL11_Draw2DImage(
+	GLuint texId,
+	const SDL_Rect& srcRect,
+	const SDL_Rect& dstRect,
+	float left,
+	float right,
+	float bottom,
+	float top
+);
+void GL11_Download(SDL_Surface* target);

miniwin/src/d3drm/backends/opengl1/renderer.cpp

@@ -1,5 +1,4 @@
-#include <GL/glew.h>
+#include "actual.h"
-// must come after GLEW
 #include "d3drmrenderer_opengl1.h"
 #include "ddraw_impl.h"
 #include "ddsurface_impl.h"
@@ -11,8 +10,20 @@
 #include <cstring>
 #include <vector>
 
+static_assert(sizeof(Matrix4x4) == sizeof(D3DRMMATRIX4D), "Matrix4x4 is wrong size");
+static_assert(sizeof(GL11_BridgeVector) == sizeof(D3DVECTOR), "GL11_BridgeVector is wrong size");
+static_assert(sizeof(GL11_BridgeTexCoord) == sizeof(TexCoord), "GL11_BridgeTexCoord is wrong size");
+static_assert(sizeof(GL11_BridgeSceneLight) == sizeof(SceneLight), "GL11_BridgeSceneLight is wrong size");
+static_assert(sizeof(GL11_BridgeSceneVertex) == sizeof(D3DRMVERTEX), "GL11_BridgeSceneVertex is wrong size");
+
 Direct3DRMRenderer* OpenGL1Renderer::Create(DWORD width, DWORD height)
 {
+	// We have to reset the attributes here after having enumerated the
+	// OpenGL ES 2.0 renderer, or else SDL gets very confused by SDL_GL_DEPTH_SIZE
+	// call below when on an EGL-based backend, and crashes with EGL_BAD_MATCH.
+	SDL_GL_ResetAttributes();
+	// But ResetAttributes resets it to 16.
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
@@ -28,8 +39,6 @@ Direct3DRMRenderer* OpenGL1Renderer::Create(DWORD width, DWORD height)
 		testWindow = true;
 	}
 
-	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
-
 	SDL_GLContext context = SDL_GL_CreateContext(window);
 	if (!context) {
 		SDL_Log("SDL_GL_CreateContext: %s", SDL_GetError());
@@ -47,18 +56,7 @@ Direct3DRMRenderer* OpenGL1Renderer::Create(DWORD width, DWORD height)
 		return nullptr;
 	}
 
-	GLenum err = glewInit();
+	GL11_InitState();
-	if (err != GLEW_OK) {
-		SDL_Log("glewInit: %s", glewGetErrorString(err));
-		if (testWindow) {
-			SDL_DestroyWindow(window);
-		}
-		return nullptr;
-	}
-
-	glEnable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-	glFrontFace(GL_CW);
 
 	if (testWindow) {
 		SDL_DestroyWindow(window);
@@ -74,7 +72,7 @@ OpenGL1Renderer::OpenGL1Renderer(DWORD width, DWORD height, SDL_GLContext contex
 	m_virtualWidth = width;
 	m_virtualHeight = height;
 	m_renderedImage = SDL_CreateSurface(m_width, m_height, SDL_PIXELFORMAT_RGBA32);
-	m_useVBOs = GLEW_ARB_vertex_buffer_object;
+	GL11_LoadExtensions();
 }
 
 OpenGL1Renderer::~OpenGL1Renderer()
@@ -114,7 +112,7 @@ void OpenGL1Renderer::AddTextureDestroyCallback(Uint32 id, IDirect3DRMTexture* t
 			auto* ctx = static_cast<TextureDestroyContextGL*>(arg);
 			auto& cache = ctx->renderer->m_textures[ctx->textureId];
 			if (cache.glTextureId != 0) {
-				glDeleteTextures(1, &cache.glTextureId);
+				GL11_DestroyTexture(cache.glTextureId);
 				cache.glTextureId = 0;
 				cache.texture = nullptr;
 			}
@@ -133,15 +131,13 @@ Uint32 OpenGL1Renderer::GetTextureId(IDirect3DRMTexture* iTexture)
 		auto& tex = m_textures[i];
 		if (tex.texture == texture) {
 			if (tex.version != texture->m_version) {
-				glDeleteTextures(1, &tex.glTextureId);
+				GL11_DestroyTexture(tex.glTextureId);
-				glGenTextures(1, &tex.glTextureId);
-				glBindTexture(GL_TEXTURE_2D, tex.glTextureId);
 
 				SDL_Surface* surf = SDL_ConvertSurface(surface->m_surface, SDL_PIXELFORMAT_RGBA32);
 				if (!surf) {
 					return NO_TEXTURE_ID;
 				}
-				glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);
+				tex.glTextureId = GL11_UploadTextureData(surf->pixels, surf->w, surf->h);
 				SDL_DestroySurface(surf);
 
 				tex.version = texture->m_version;
@@ -151,14 +147,12 @@ Uint32 OpenGL1Renderer::GetTextureId(IDirect3DRMTexture* iTexture)
 	}
 
 	GLuint texId;
-	glGenTextures(1, &texId);
-	glBindTexture(GL_TEXTURE_2D, texId);
 
 	SDL_Surface* surf = SDL_ConvertSurface(surface->m_surface, SDL_PIXELFORMAT_RGBA32);
 	if (!surf) {
 		return NO_TEXTURE_ID;
 	}
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);
+	texId = GL11_UploadTextureData(surf->pixels, surf->w, surf->h);
 	SDL_DestroySurface(surf);
 
 	for (Uint32 i = 0; i < m_textures.size(); ++i) {
@@ -206,52 +200,19 @@ GLMeshCacheEntry GLUploadMesh(const MeshGroup& meshGroup, bool useVBOs)
 	if (meshGroup.texture) {
 		cache.texcoords.resize(vertices.size());
 		std::transform(vertices.begin(), vertices.end(), cache.texcoords.begin(), [](const D3DRMVERTEX& v) {
-			return v.texCoord;
+			return GL11_BridgeTexCoord{v.texCoord.u, v.texCoord.v};
 		});
 	}
 	cache.positions.resize(vertices.size());
 	std::transform(vertices.begin(), vertices.end(), cache.positions.begin(), [](const D3DRMVERTEX& v) {
-		return v.position;
+		return GL11_BridgeVector{v.position.x, v.position.y, v.position.z};
 	});
 	cache.normals.resize(vertices.size());
 	std::transform(vertices.begin(), vertices.end(), cache.normals.begin(), [](const D3DRMVERTEX& v) {
-		return v.normal;
+		return GL11_BridgeVector{v.normal.x, v.normal.y, v.normal.z};
 	});
 
-	if (useVBOs) {
+	GL11_UploadMesh(cache, meshGroup.texture != nullptr);
-		glGenBuffers(1, &cache.vboPositions);
-		glBindBuffer(GL_ARRAY_BUFFER, cache.vboPositions);
-		glBufferData(
-			GL_ARRAY_BUFFER,
-			cache.positions.size() * sizeof(D3DVECTOR),
-			cache.positions.data(),
-			GL_STATIC_DRAW
-		);
-
-		glGenBuffers(1, &cache.vboNormals);
-		glBindBuffer(GL_ARRAY_BUFFER, cache.vboNormals);
-		glBufferData(GL_ARRAY_BUFFER, cache.normals.size() * sizeof(D3DVECTOR), cache.normals.data(), GL_STATIC_DRAW);
-
-		if (meshGroup.texture) {
-			glGenBuffers(1, &cache.vboTexcoords);
-			glBindBuffer(GL_ARRAY_BUFFER, cache.vboTexcoords);
-			glBufferData(
-				GL_ARRAY_BUFFER,
-				cache.texcoords.size() * sizeof(TexCoord),
-				cache.texcoords.data(),
-				GL_STATIC_DRAW
-			);
-		}
-
-		glGenBuffers(1, &cache.ibo);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache.ibo);
-		glBufferData(
-			GL_ELEMENT_ARRAY_BUFFER,
-			cache.indices.size() * sizeof(cache.indices[0]),
-			cache.indices.data(),
-			GL_STATIC_DRAW
-		);
-	}
 
 	return cache;
 }
@@ -269,12 +230,7 @@ void OpenGL1Renderer::AddMeshDestroyCallback(Uint32 id, IDirect3DRMMesh* mesh)
 			auto* ctx = static_cast<GLMeshDestroyContext*>(arg);
 			auto& cache = ctx->renderer->m_meshs[ctx->id];
 			cache.meshGroup = nullptr;
-			if (ctx->renderer->m_useVBOs) {
+			GL11_DestroyMesh(cache);
-				glDeleteBuffers(1, &cache.vboPositions);
-				glDeleteBuffers(1, &cache.vboNormals);
-				glDeleteBuffers(1, &cache.vboTexcoords);
-				glDeleteBuffers(1, &cache.ibo);
-			}
 			delete ctx;
 		},
 		ctx
@@ -329,90 +285,23 @@ const char* OpenGL1Renderer::GetName()
 
 HRESULT OpenGL1Renderer::BeginFrame()
 {
-	m_dirty = true;
+	GL11_BeginFrame((Matrix4x4*) &m_projection[0][0]);
-
-	glDisable(GL_BLEND);
-	glEnable(GL_DEPTH_TEST);
-	glDepthMask(GL_TRUE);
-	glEnable(GL_LIGHTING);
-	glEnable(GL_COLOR_MATERIAL);
-	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
-
-	// Disable all lights and reset global ambient
-	for (int i = 0; i < 8; ++i) {
-		glDisable(GL_LIGHT0 + i);
-	}
-	const GLfloat zeroAmbient[4] = {0.f, 0.f, 0.f, 1.f};
-	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, zeroAmbient);
-	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
-
-	// Setup lights
-	glMatrixMode(GL_MODELVIEW);
-	glPushMatrix();
-	glLoadIdentity();
 
 	int lightIdx = 0;
 	for (const auto& l : m_lights) {
 		if (lightIdx > 7) {
 			break;
 		}
-		GLenum lightId = GL_LIGHT0 + lightIdx++;
+		GL11_UploadLight(lightIdx, (GL11_BridgeSceneLight*) &l);
-		const FColor& c = l.color;
-		GLfloat col[4] = {c.r, c.g, c.b, c.a};
 
-		if (l.positional == 0.f && l.directional == 0.f) {
+		lightIdx++;
-			// Ambient light only
-			glLightfv(lightId, GL_AMBIENT, col);
-			const GLfloat black[4] = {0.f, 0.f, 0.f, 1.f};
-			glLightfv(lightId, GL_DIFFUSE, black);
-			glLightfv(lightId, GL_SPECULAR, black);
-			const GLfloat dummyPos[4] = {0.f, 0.f, 1.f, 0.f};
-			glLightfv(lightId, GL_POSITION, dummyPos);
-		}
-		else {
-			glLightfv(lightId, GL_AMBIENT, zeroAmbient);
-			glLightfv(lightId, GL_DIFFUSE, col);
-			if (l.directional == 1.0f) {
-				glLightfv(lightId, GL_SPECULAR, col);
-			}
-			else {
-				const GLfloat black[4] = {0.f, 0.f, 0.f, 1.f};
-				glLightfv(lightId, GL_SPECULAR, black);
-			}
-
-			GLfloat pos[4];
-			if (l.directional == 1.f) {
-				pos[0] = -l.direction.x;
-				pos[1] = -l.direction.y;
-				pos[2] = -l.direction.z;
-				pos[3] = 0.f;
-			}
-			else {
-				pos[0] = l.position.x;
-				pos[1] = l.position.y;
-				pos[2] = l.position.z;
-				pos[3] = 1.f;
-			}
-			glLightfv(lightId, GL_POSITION, pos);
-		}
-		glEnable(lightId);
 	}
-	glPopMatrix();
-
-	// Projection and view
-	glMatrixMode(GL_PROJECTION);
-	glLoadMatrixf(&m_projection[0][0]);
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-
 	return DD_OK;
 }
 
 void OpenGL1Renderer::EnableTransparency()
 {
-	glEnable(GL_BLEND);
+	GL11_EnableTransparency();
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glDepthMask(GL_FALSE);
 }
 
 void OpenGL1Renderer::SubmitDraw(
@@ -426,75 +315,14 @@ void OpenGL1Renderer::SubmitDraw(
 {
 	auto& mesh = m_meshs[meshId];
 
-	glLoadMatrixf(&modelViewMatrix[0][0]);
-	glEnable(GL_NORMALIZE);
-
-	glColor4ub(appearance.color.r, appearance.color.g, appearance.color.b, appearance.color.a);
-
-	if (appearance.shininess != 0.0f) {
-		GLfloat whiteSpec[] = {1.f, 1.f, 1.f, 1.f};
-		glMaterialfv(GL_FRONT, GL_SPECULAR, whiteSpec);
-		glMaterialf(GL_FRONT, GL_SHININESS, appearance.shininess);
-	}
-	else {
-		GLfloat noSpec[] = {0.0f, 0.0f, 0.0f, 0.0f};
-		glMaterialfv(GL_FRONT, GL_SPECULAR, noSpec);
-		glMaterialf(GL_FRONT, GL_SHININESS, 0.0f);
-	}
-
-	if (mesh.flat) {
-		glShadeModel(GL_FLAT);
-	}
-	else {
-		glShadeModel(GL_SMOOTH);
-	}
-
 	// Bind texture if present
 	if (appearance.textureId != NO_TEXTURE_ID) {
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 		auto& tex = m_textures[appearance.textureId];
-		glEnable(GL_TEXTURE_2D);
+		GL11_SubmitDraw(mesh, modelViewMatrix, appearance, tex.glTextureId);
-		glBindTexture(GL_TEXTURE_2D, tex.glTextureId);
-		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 	}
 	else {
-		glDisable(GL_TEXTURE_2D);
+		GL11_SubmitDraw(mesh, modelViewMatrix, appearance, 0);
-		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 	}
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glEnableClientState(GL_NORMAL_ARRAY);
-
-	if (m_useVBOs) {
-		glBindBuffer(GL_ARRAY_BUFFER, mesh.vboPositions);
-		glVertexPointer(3, GL_FLOAT, 0, nullptr);
-
-		glBindBuffer(GL_ARRAY_BUFFER, mesh.vboNormals);
-		glNormalPointer(GL_FLOAT, 0, nullptr);
-
-		if (appearance.textureId != NO_TEXTURE_ID) {
-			glBindBuffer(GL_ARRAY_BUFFER, mesh.vboTexcoords);
-			glTexCoordPointer(2, GL_FLOAT, 0, nullptr);
-		}
-
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.ibo);
-		glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(mesh.indices.size()), GL_UNSIGNED_SHORT, nullptr);
-
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-	}
-	else {
-		glVertexPointer(3, GL_FLOAT, 0, mesh.positions.data());
-		glNormalPointer(GL_FLOAT, 0, mesh.normals.data());
-		if (appearance.textureId != NO_TEXTURE_ID) {
-			glTexCoordPointer(2, GL_FLOAT, 0, mesh.texcoords.data());
-		}
-
-		glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(mesh.indices.size()), GL_UNSIGNED_SHORT, mesh.indices.data());
-	}
-
-	glPopMatrix();
 }
 
 HRESULT OpenGL1Renderer::FinalizeFrame()
@@ -509,16 +337,13 @@ void OpenGL1Renderer::Resize(int width, int height, const ViewportTransform& vie
 	m_viewportTransform = viewportTransform;
 	SDL_DestroySurface(m_renderedImage);
 	m_renderedImage = SDL_CreateSurface(m_width, m_height, SDL_PIXELFORMAT_RGBA32);
-	glViewport(0, 0, m_width, m_height);
+	GL11_Resize(width, height);
 }
 
 void OpenGL1Renderer::Clear(float r, float g, float b)
 {
 	m_dirty = true;
-	glEnable(GL_DEPTH_TEST);
+	GL11_Clear(r, g, b);
-	glDepthMask(GL_TRUE);
-	glClearColor(r, g, b, 1.0f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
 
 void OpenGL1Renderer::Flip()
@@ -532,73 +357,18 @@ void OpenGL1Renderer::Flip()
 void OpenGL1Renderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const SDL_Rect& dstRect)
 {
 	m_dirty = true;
-	glDisable(GL_DEPTH_TEST);
-	glDepthMask(GL_FALSE);
-
-	glMatrixMode(GL_PROJECTION);
-	glPushMatrix();
-	glLoadIdentity();
 
 	float left = -m_viewportTransform.offsetX / m_viewportTransform.scale;
 	float right = (m_width - m_viewportTransform.offsetX) / m_viewportTransform.scale;
 	float top = -m_viewportTransform.offsetY / m_viewportTransform.scale;
 	float bottom = (m_height - m_viewportTransform.offsetY) / m_viewportTransform.scale;
-	glOrtho(left, right, bottom, top, -1, 1);
 
-	glMatrixMode(GL_MODELVIEW);
+	GL11_Draw2DImage(m_textures[textureId].glTextureId, srcRect, dstRect, left, right, bottom, top);
-	glPushMatrix();
-	glLoadIdentity();
-
-	glDisable(GL_LIGHTING);
-	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-
-	glEnable(GL_TEXTURE_2D);
-	glBindTexture(GL_TEXTURE_2D, m_textures[textureId].glTextureId);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-	GLint boundTexture = 0;
-	glGetIntegerv(GL_TEXTURE_BINDING_2D, &boundTexture);
-
-	GLfloat texW, texH;
-	glGetTexLevelParameterfv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &texW);
-	glGetTexLevelParameterfv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &texH);
-
-	float u1 = srcRect.x / texW;
-	float v1 = srcRect.y / texH;
-	float u2 = (srcRect.x + srcRect.w) / texW;
-	float v2 = (srcRect.y + srcRect.h) / texH;
-
-	float x1 = (float) dstRect.x;
-	float y1 = (float) dstRect.y;
-	float x2 = x1 + dstRect.w;
-	float y2 = y1 + dstRect.h;
-
-	glBegin(GL_QUADS);
-	glTexCoord2f(u1, v1);
-	glVertex2f(x1, y1);
-	glTexCoord2f(u2, v1);
-	glVertex2f(x2, y1);
-	glTexCoord2f(u2, v2);
-	glVertex2f(x2, y2);
-	glTexCoord2f(u1, v2);
-	glVertex2f(x1, y2);
-	glEnd();
-
-	// Restore state
-	glMatrixMode(GL_MODELVIEW);
-	glPopMatrix();
-	glMatrixMode(GL_PROJECTION);
-	glPopMatrix();
 }
 
 void OpenGL1Renderer::Download(SDL_Surface* target)
 {
-	glFinish();
+	GL11_Download(m_renderedImage);
-	glReadPixels(0, 0, m_width, m_height, GL_RGBA, GL_UNSIGNED_BYTE, m_renderedImage->pixels);
 
 	SDL_Rect srcRect = {
 		static_cast<int>(m_viewportTransform.offsetX),

miniwin/src/d3drm/backends/opengles2/renderer.cpp

@@ -30,6 +30,12 @@ struct SceneLightGLES2 {
 
 Direct3DRMRenderer* OpenGLES2Renderer::Create(DWORD width, DWORD height)
 {
+	// We have to reset the attributes here after having enumerated the
+	// OpenGL ES 2.0 renderer, or else SDL gets very confused by SDL_GL_DEPTH_SIZE
+	// call below when on an EGL-based backend, and crashes with EGL_BAD_MATCH.
+	SDL_GL_ResetAttributes();
+	// But ResetAttributes resets it to 16.
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
@@ -41,8 +47,6 @@ Direct3DRMRenderer* OpenGLES2Renderer::Create(DWORD width, DWORD height)
 		testWindow = true;
 	}
 
-	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
-
 	SDL_GLContext context = SDL_GL_CreateContext(window);
 	if (!context) {
 		if (testWindow) {

miniwin/src/internal/d3drmrenderer_opengl1.h

@@ -1,44 +1,14 @@
 #pragma once
-
+#include "../d3drm/backends/opengl1/actual.h"
 #include "d3drmrenderer.h"
 #include "d3drmtexture_impl.h"
 #include "ddraw_impl.h"
 
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
-
 #include <SDL3/SDL.h>
 #include <vector>
 
 DEFINE_GUID(OpenGL1_GUID, 0x682656F3, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03);
 
-struct GLTextureCacheEntry {
-	IDirect3DRMTexture* texture;
-	Uint32 version;
-	GLuint glTextureId;
-};
-
-struct GLMeshCacheEntry {
-	const MeshGroup* meshGroup;
-	int version;
-	bool flat;
-
-	// non-VBO cache
-	std::vector<D3DVECTOR> positions;
-	std::vector<D3DVECTOR> normals;
-	std::vector<TexCoord> texcoords;
-	std::vector<uint16_t> indices;
-
-	// VBO cache
-	GLuint vboPositions;
-	GLuint vboNormals;
-	GLuint vboTexcoords;
-	GLuint ibo;
-};
-
 class OpenGL1Renderer : public Direct3DRMRenderer {
 public:
 	static Direct3DRMRenderer* Create(DWORD width, DWORD height);