src/gba/renderers/gl.c (view raw)
1/* Copyright (c) 2013-2019 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#include <mgba/internal/gba/renderers/gl.h>
7
8#if defined(BUILD_GLES2) || defined(BUILD_GLES3)
9
10#include <mgba/core/cache-set.h>
11#include <mgba/internal/arm/macros.h>
12#include <mgba/internal/gba/io.h>
13#include <mgba/internal/gba/renderers/cache-set.h>
14#include <mgba-util/memory.h>
15
16static void GBAVideoGLRendererInit(struct GBAVideoRenderer* renderer);
17static void GBAVideoGLRendererDeinit(struct GBAVideoRenderer* renderer);
18static void GBAVideoGLRendererReset(struct GBAVideoRenderer* renderer);
19static void GBAVideoGLRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address);
20static void GBAVideoGLRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam);
21static void GBAVideoGLRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value);
22static uint16_t GBAVideoGLRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value);
23static void GBAVideoGLRendererDrawScanline(struct GBAVideoRenderer* renderer, int y);
24static void GBAVideoGLRendererFinishFrame(struct GBAVideoRenderer* renderer);
25static void GBAVideoGLRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels);
26static void GBAVideoGLRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels);
27
28static void GBAVideoGLRendererUpdateDISPCNT(struct GBAVideoGLRenderer* renderer);
29static void GBAVideoGLRendererWriteBGCNT(struct GBAVideoGLBackground* bg, uint16_t value);
30static void GBAVideoGLRendererWriteBGX_LO(struct GBAVideoGLBackground* bg, uint16_t value);
31static void GBAVideoGLRendererWriteBGX_HI(struct GBAVideoGLBackground* bg, uint16_t value);
32static void GBAVideoGLRendererWriteBGY_LO(struct GBAVideoGLBackground* bg, uint16_t value);
33static void GBAVideoGLRendererWriteBGY_HI(struct GBAVideoGLBackground* bg, uint16_t value);
34static void GBAVideoGLRendererWriteBLDCNT(struct GBAVideoGLRenderer* renderer, uint16_t value);
35
36static void GBAVideoGLRendererDrawSprite(struct GBAVideoGLRenderer* renderer, struct GBAObj* sprite, int y, int spriteY);
37static void GBAVideoGLRendererDrawBackgroundMode0(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y);
38static void GBAVideoGLRendererDrawBackgroundMode2(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y);
39static void GBAVideoGLRendererDrawBackgroundMode3(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y);
40static void GBAVideoGLRendererDrawBackgroundMode4(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y);
41static void GBAVideoGLRendererDrawBackgroundMode5(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y);
42static void GBAVideoGLRendererDrawWindow(struct GBAVideoGLRenderer* renderer, int y);
43
44static void _cleanRegister(struct GBAVideoGLRenderer* renderer, int address, uint16_t value);
45static void _drawScanlines(struct GBAVideoGLRenderer* renderer, int lastY);
46static void _finalizeLayers(struct GBAVideoGLRenderer* renderer);
47
48#define TEST_LAYER_ENABLED(X) !glRenderer->d.disableBG[X] && glRenderer->bg[X].enabled == 4
49
50struct GBAVideoGLUniform {
51 const char* name;
52 int type;
53};
54
55#define PALETTE_ENTRY "#define PALETTE_ENTRY(x) (vec3((ivec3(0x1F, 0x3E0, 0x7C00) & (x)) >> ivec3(0, 5, 10)) / 31.)\n"
56
57static const GLchar* const _gles3Header =
58 "#version 300 es\n"
59 "#define OUT(n) layout(location = n)\n"
60 PALETTE_ENTRY
61 "precision highp float;\n"
62 "precision highp int;\n"
63 "precision highp sampler2D;\n"
64 "precision highp isampler2D;\n";
65
66static const GLchar* const _gl3Header =
67 "#version 150 core\n"
68 "#define OUT(n)\n"
69 PALETTE_ENTRY
70 "precision highp float;\n";
71
72static const char* const _vertexShader =
73 "in vec2 position;\n"
74 "uniform ivec2 loc;\n"
75 "uniform ivec2 maxPos;\n"
76 "out vec2 texCoord;\n"
77
78 "void main() {\n"
79 " vec2 local = vec2(position.x, float(position.y * float(loc.x) + float(loc.y)) / float(maxPos.y));\n"
80 " gl_Position = vec4((local * 2. - 1.) * vec2(sign(maxPos)), 0., 1.);\n"
81 " texCoord = local * vec2(abs(maxPos));\n"
82 "}";
83
84static const char* const _renderTile16 =
85 "vec4 renderTile(int tile, int paletteId, ivec2 localCoord) {\n"
86 " int address = charBase + tile * 16 + (localCoord.x >> 2) + (localCoord.y << 1);\n"
87 " vec4 halfrow = texelFetch(vram, ivec2(address & 255, address >> 8), 0);\n"
88 " int entry = int(halfrow[3 - (localCoord.x & 3)] * 15.9);\n"
89 " if (entry == 0) {\n"
90 " discard;\n"
91 " }\n"
92 " int paletteEntry = palette[paletteId * 16 + entry];\n"
93 " vec4 color = vec4(PALETTE_ENTRY(paletteEntry), 1.);\n"
94 " return color;\n"
95 "}";
96
97static const char* const _renderTile256 =
98 "vec4 renderTile(int tile, int paletteId, ivec2 localCoord) {\n"
99 " int address = charBase + tile * 32 + (localCoord.x >> 1) + (localCoord.y << 2);\n"
100 " vec4 halfrow = texelFetch(vram, ivec2(address & 255, address >> 8), 0);\n"
101 " int entry = int(halfrow[3 - 2 * (localCoord.x & 1)] * 15.9);\n"
102 " int pal2 = int(halfrow[2 - 2 * (localCoord.x & 1)] * 15.9);\n"
103 " if ((pal2 | entry) == 0) {\n"
104 " discard;\n"
105 " }\n"
106 " int paletteEntry = palette[pal2 * 16 + entry];\n"
107 " vec4 color = vec4(PALETTE_ENTRY(paletteEntry), 1.);\n"
108 " return color;\n"
109 "}";
110
111static const struct GBAVideoGLUniform _uniformsMode0[] = {
112 { "loc", GBA_GL_VS_LOC, },
113 { "maxPos", GBA_GL_VS_MAXPOS, },
114 { "vram", GBA_GL_BG_VRAM, },
115 { "palette", GBA_GL_BG_PALETTE, },
116 { "screenBase", GBA_GL_BG_SCREENBASE, },
117 { "charBase", GBA_GL_BG_CHARBASE, },
118 { "size", GBA_GL_BG_SIZE, },
119 { "offset", GBA_GL_BG_OFFSET, },
120 { "inflags", GBA_GL_BG_INFLAGS, },
121 { "mosaic", GBA_GL_BG_MOSAIC, },
122 { 0 }
123};
124
125static const char* const _renderMode0 =
126 "in vec2 texCoord;\n"
127 "uniform sampler2D vram;\n"
128 "uniform int palette[256];\n"
129 "uniform int screenBase;\n"
130 "uniform int charBase;\n"
131 "uniform int size;\n"
132 "uniform int offset[160];\n"
133 "uniform ivec4 inflags;\n"
134 "uniform ivec2 mosaic;\n"
135 "OUT(0) out vec4 color;\n"
136 "OUT(1) out ivec4 flags;\n"
137
138 "vec4 renderTile(int tile, int paletteId, ivec2 localCoord);\n"
139
140 "void main() {\n"
141 " ivec2 coord = ivec2(texCoord);\n"
142 " if (mosaic.x > 1) {\n"
143 " coord.x -= coord.x % mosaic.x;\n"
144 " }\n"
145 " if (mosaic.y > 1) {\n"
146 " coord.y -= coord.y % mosaic.y;\n"
147 " }\n"
148 " coord += (ivec2(0x1FF, 0x1FF000) & offset[int(texCoord.y)]) >> ivec2(0, 12);\n"
149 " ivec2 wrap = ivec2(255, 255);\n"
150 " int doty = 0;\n"
151 " if ((size & 1) == 1) {\n"
152 " wrap.x = 511;\n"
153 " ++doty;\n"
154 " }\n"
155 " if ((size & 2) == 2) {\n"
156 " wrap.y = 511;\n"
157 " ++doty;\n"
158 " }\n"
159 " coord &= wrap;\n"
160 " wrap = coord & 256;\n"
161 " coord &= 255;\n"
162 " coord.y += wrap.x + wrap.y * doty;\n"
163 " int mapAddress = screenBase + (coord.x >> 3) + (coord.y >> 3) * 32;\n"
164 " vec4 map = texelFetch(vram, ivec2(mapAddress & 255, mapAddress >> 8), 0);\n"
165 " int tileFlags = int(map.g * 15.9);\n"
166 " if ((tileFlags & 4) == 4) {\n"
167 " coord.x ^= 7;\n"
168 " }\n"
169 " if ((tileFlags & 8) == 8) {\n"
170 " coord.y ^= 7;\n"
171 " }\n"
172 " int tile = int(map.a * 15.9) + int(map.b * 15.9) * 16 + (tileFlags & 0x3) * 256;\n"
173 " color = renderTile(tile, int(map.r * 15.9), coord & 7);\n"
174 " flags = inflags;\n"
175 "}";
176
177static const char* const _fetchTileOverflow =
178 "vec4 fetchTile(ivec2 coord) {\n"
179 " int sizeAdjusted = (0x8000 << size) - 1;\n"
180 " coord &= sizeAdjusted;\n"
181 " return renderTile(coord);\n"
182 "}";
183
184static const char* const _fetchTileNoOverflow =
185 "vec4 fetchTile(ivec2 coord) {\n"
186 " int sizeAdjusted = (0x8000 << size) - 1;\n"
187 " ivec2 outerCoord = coord & ~sizeAdjusted;\n"
188 " if ((outerCoord.x | outerCoord.y) != 0) {\n"
189 " discard;\n"
190 " }\n"
191 " return renderTile(coord);\n"
192 "}";
193
194static const struct GBAVideoGLUniform _uniformsMode2[] = {
195 { "loc", GBA_GL_VS_LOC, },
196 { "maxPos", GBA_GL_VS_MAXPOS, },
197 { "vram", GBA_GL_BG_VRAM, },
198 { "palette", GBA_GL_BG_PALETTE, },
199 { "screenBase", GBA_GL_BG_SCREENBASE, },
200 { "charBase", GBA_GL_BG_CHARBASE, },
201 { "size", GBA_GL_BG_SIZE, },
202 { "inflags", GBA_GL_BG_INFLAGS, },
203 { "offset", GBA_GL_BG_OFFSET, },
204 { "transform", GBA_GL_BG_TRANSFORM, },
205 { "range", GBA_GL_BG_RANGE, },
206 { "mosaic", GBA_GL_BG_MOSAIC, },
207 { 0 }
208};
209
210static const char* const _interpolate =
211 "vec2 interpolate(ivec2 arr[4], float x) {\n"
212 " float x1m = 1. - x;\n"
213 " return x1m * x1m * x1m * vec2(arr[0]) +"
214 " 3. * x1m * x1m * x * vec2(arr[1]) +"
215 " 3. * x1m * x * x * vec2(arr[2]) +"
216 " x * x * x * vec2(arr[3]);\n"
217 "}\n"
218
219 "void loadAffine(int y, out ivec2 mat[4], out ivec2 aff[4]) {\n"
220 " int start = max(range.x, y - 3);\n"
221 " mat[0] = transform[start + 0].xy;\n"
222 " aff[0] = transform[start + 0].zw;\n"
223 " mat[1] = transform[start + 1].xy;\n"
224 " aff[1] = transform[start + 1].zw;\n"
225 " mat[2] = transform[start + 2].xy;\n"
226 " aff[2] = transform[start + 2].zw;\n"
227 " mat[3] = transform[start + 3].xy;\n"
228 " aff[3] = transform[start + 3].zw;\n"
229 "}\n";
230
231static const char* const _renderMode2 =
232 "in vec2 texCoord;\n"
233 "uniform sampler2D vram;\n"
234 "uniform int palette[256];\n"
235 "uniform int screenBase;\n"
236 "uniform int charBase;\n"
237 "uniform int size;\n"
238 "uniform ivec4 inflags;\n"
239 "uniform ivec4 transform[160];\n"
240 "uniform ivec2 range;\n"
241 "uniform ivec2 mosaic;\n"
242 "OUT(0) out vec4 color;\n"
243 "OUT(1) out ivec4 flags;\n"
244
245 "vec4 fetchTile(ivec2 coord);\n"
246 "vec2 interpolate(ivec2 arr[4], float x);\n"
247 "void loadAffine(int y, out ivec2 mat[4], out ivec2 aff[4]);\n"
248
249 "vec4 renderTile(ivec2 coord) {\n"
250 " int map = (coord.x >> 11) + (((coord.y >> 7) & 0x7F0) << size);\n"
251 " int mapAddress = screenBase + (map >> 1);\n"
252 " vec4 twomaps = texelFetch(vram, ivec2(mapAddress & 255, mapAddress >> 8), 0);\n"
253 " int tile = int(twomaps[3 - 2 * (map & 1)] * 15.9) + int(twomaps[2 - 2 * (map & 1)] * 15.9) * 16;\n"
254 " int address = charBase + tile * 32 + ((coord.x >> 9) & 3) + ((coord.y >> 6) & 0x1C);\n"
255 " vec4 halfrow = texelFetch(vram, ivec2(address & 255, address >> 8), 0);\n"
256 " int entry = int(halfrow[3 - ((coord.x >> 7) & 2)] * 15.9);\n"
257 " int pal2 = int(halfrow[2 - ((coord.x >> 7) & 2)] * 15.9);\n"
258 " if ((pal2 | entry) == 0) {\n"
259 " discard;\n"
260 " }\n"
261 " int paletteEntry = palette[pal2 * 16 + entry];\n"
262 " vec4 color = vec4(PALETTE_ENTRY(paletteEntry), 1.);\n"
263 " return color;\n"
264 "}\n"
265
266 "void main() {\n"
267 " ivec2 mat[4];\n"
268 " ivec2 offset[4];\n"
269 " vec2 incoord = texCoord;\n"
270 " if (mosaic.x > 1) {\n"
271 " incoord.x = floor(incoord.x - float(int(incoord.x) % mosaic.x));\n"
272 " }\n"
273 " if (mosaic.y > 1) {\n"
274 " incoord.y = floor(incoord.y - float(int(incoord.y) % mosaic.y));\n"
275 " }\n"
276 " loadAffine(int(incoord.y), mat, offset);\n"
277 " float y = fract(incoord.y);\n"
278 " float start = 0.75;\n"
279 " if (int(incoord.y) - range.x < 4) {\n"
280 " y = incoord.y - float(range.x);\n"
281 " start = 0.;\n"
282 " }\n"
283 " float lin = start + y * 0.25;\n"
284 " vec2 mixedTransform = interpolate(mat, lin);\n"
285 " vec2 mixedOffset = interpolate(offset, lin);\n"
286 " color = fetchTile(ivec2(mixedTransform * incoord.x + mixedOffset));\n"
287 " flags = inflags;\n"
288 "}";
289
290static const struct GBAVideoGLUniform _uniformsMode35[] = {
291 { "loc", GBA_GL_VS_LOC, },
292 { "maxPos", GBA_GL_VS_MAXPOS, },
293 { "vram", GBA_GL_BG_VRAM, },
294 { "charBase", GBA_GL_BG_CHARBASE, },
295 { "size", GBA_GL_BG_SIZE, },
296 { "inflags", GBA_GL_BG_INFLAGS, },
297 { "offset", GBA_GL_BG_OFFSET, },
298 { "transform", GBA_GL_BG_TRANSFORM, },
299 { "range", GBA_GL_BG_RANGE, },
300 { "mosaic", GBA_GL_BG_MOSAIC, },
301 { 0 }
302};
303
304static const char* const _renderMode35 =
305 "in vec2 texCoord;\n"
306 "uniform sampler2D vram;\n"
307 "uniform int charBase;\n"
308 "uniform ivec2 size;\n"
309 "uniform ivec4 inflags;\n"
310 "uniform ivec4 transform[160];\n"
311 "uniform ivec2 range;\n"
312 "uniform ivec2 mosaic;\n"
313 "OUT(0) out vec4 color;\n"
314 "OUT(1) out ivec4 flags;\n"
315
316 "vec2 interpolate(ivec2 arr[4], float x);\n"
317 "void loadAffine(int y, out ivec2 mat[4], out ivec2 aff[4]);\n"
318
319 "void main() {\n"
320 " ivec2 mat[4];\n"
321 " ivec2 offset[4];\n"
322 " vec2 incoord = texCoord;\n"
323 " if (mosaic.x > 1) {\n"
324 " incoord.x = floor(incoord.x - float(int(incoord.x) % mosaic.x));\n"
325 " }\n"
326 " if (mosaic.y > 1) {\n"
327 " incoord.y = floor(incoord.y - float(int(incoord.y) % mosaic.y));\n"
328 " }\n"
329 " loadAffine(int(incoord.y), mat, offset);\n"
330 " float y = fract(incoord.y);\n"
331 " float start = 0.75;\n"
332 " if (int(incoord.y) - range.x < 4) {\n"
333 " y = incoord.y - float(range.x);\n"
334 " start = 0.;\n"
335 " }\n"
336 " float lin = start + y * 0.25;\n"
337 " vec2 mixedTransform = interpolate(mat, lin);\n"
338 " vec2 mixedOffset = interpolate(offset, lin);\n"
339 " ivec2 coord = ivec2(mixedTransform * incoord.x + mixedOffset);\n"
340 " if (coord.x < 0 || coord.x >= (size.x << 8)) {\n"
341 " discard;\n"
342 " }\n"
343 " if (coord.y < 0 || coord.y >= (size.y << 8)) {\n"
344 " discard;\n"
345 " }\n"
346 " int address = charBase + (coord.x >> 8) + (coord.y >> 8) * size.x;\n"
347 " ivec4 entry = ivec4(texelFetch(vram, ivec2(address & 255, address >> 8), 0) * 15.9);\n"
348 " int sixteen = (entry.x << 12) | (entry.y << 8) | (entry.z << 4) | entry.w;\n"
349 " color = vec4(float(sixteen & 0x1F) / 31., float((sixteen >> 5) & 0x1F) / 31., float((sixteen >> 10) & 0x1F) / 31., 1.);\n"
350 " flags = inflags;\n"
351 "}";
352
353static const struct GBAVideoGLUniform _uniformsMode4[] = {
354 { "loc", GBA_GL_VS_LOC, },
355 { "maxPos", GBA_GL_VS_MAXPOS, },
356 { "vram", GBA_GL_BG_VRAM, },
357 { "palette", GBA_GL_BG_PALETTE, },
358 { "charBase", GBA_GL_BG_CHARBASE, },
359 { "size", GBA_GL_BG_SIZE, },
360 { "inflags", GBA_GL_BG_INFLAGS, },
361 { "offset", GBA_GL_BG_OFFSET, },
362 { "transform", GBA_GL_BG_TRANSFORM, },
363 { "range", GBA_GL_BG_RANGE, },
364 { "mosaic", GBA_GL_BG_MOSAIC, },
365 { 0 }
366};
367
368static const char* const _renderMode4 =
369 "in vec2 texCoord;\n"
370 "uniform sampler2D vram;\n"
371 "uniform int palette[256];\n"
372 "uniform int charBase;\n"
373 "uniform ivec2 size;\n"
374 "uniform ivec4 inflags;\n"
375 "uniform ivec4 transform[160];\n"
376 "uniform ivec2 range;\n"
377 "uniform ivec2 mosaic;\n"
378 "OUT(0) out vec4 color;\n"
379 "OUT(1) out ivec4 flags;\n"
380
381 "vec2 interpolate(ivec2 arr[4], float x);\n"
382 "void loadAffine(int y, out ivec2 mat[4], out ivec2 aff[4]);\n"
383
384 "void main() {\n"
385 " ivec2 mat[4];\n"
386 " ivec2 offset[4];\n"
387 " vec2 incoord = texCoord;\n"
388 " if (mosaic.x > 1) {\n"
389 " incoord.x = floor(incoord.x - float(int(incoord.x) % mosaic.x));\n"
390 " }\n"
391 " if (mosaic.y > 1) {\n"
392 " incoord.y = floor(incoord.y - float(int(incoord.y) % mosaic.y));\n"
393 " }\n"
394 " loadAffine(int(incoord.y), mat, offset);\n"
395 " float y = fract(incoord.y);\n"
396 " float start = 0.75;\n"
397 " if (int(incoord.y) - range.x < 4) {\n"
398 " y = incoord.y - float(range.x);\n"
399 " start = 0.;\n"
400 " }\n"
401 " float lin = start + y * 0.25;\n"
402 " vec2 mixedTransform = interpolate(mat, lin);\n"
403 " vec2 mixedOffset = interpolate(offset, lin);\n"
404 " ivec2 coord = ivec2(mixedTransform * incoord.x + mixedOffset);\n"
405 " if (coord.x < 0 || coord.x >= (size.x << 8)) {\n"
406 " discard;\n"
407 " }\n"
408 " if (coord.y < 0 || coord.y >= (size.y << 8)) {\n"
409 " discard;\n"
410 " }\n"
411 " int address = charBase + (coord.x >> 8) + (coord.y >> 8) * size.x;\n"
412 " vec4 twoEntries = texelFetch(vram, ivec2((address >> 1) & 255, address >> 9), 0);\n"
413 " int entry = int(twoEntries[2 - 2 * (address & 1)] * 15.9) * 16 + int(twoEntries[3 - 2 * (address & 1)] * 15.9);\n"
414 " if (entry == 0) {\n"
415 " discard;\n"
416 " }\n"
417 " int paletteEntry = palette[entry];\n"
418 " color = vec4(PALETTE_ENTRY(paletteEntry), 1.);\n"
419 " flags = inflags;\n"
420 "}";
421
422static const struct GBAVideoGLUniform _uniformsObj[] = {
423 { "loc", GBA_GL_VS_LOC, },
424 { "maxPos", GBA_GL_VS_MAXPOS, },
425 { "vram", GBA_GL_OBJ_VRAM, },
426 { "palette", GBA_GL_OBJ_PALETTE, },
427 { "charBase", GBA_GL_OBJ_CHARBASE, },
428 { "stride", GBA_GL_OBJ_STRIDE, },
429 { "localPalette", GBA_GL_OBJ_LOCALPALETTE, },
430 { "inflags", GBA_GL_OBJ_INFLAGS, },
431 { "transform", GBA_GL_OBJ_TRANSFORM, },
432 { "dims", GBA_GL_OBJ_DIMS, },
433 { "objwin", GBA_GL_OBJ_OBJWIN, },
434 { "mosaic", GBA_GL_OBJ_MOSAIC, },
435 { 0 }
436};
437
438static const char* const _renderObj =
439 "in vec2 texCoord;\n"
440 "uniform sampler2D vram;\n"
441 "uniform int palette[256];\n"
442 "uniform int charBase;\n"
443 "uniform int stride;\n"
444 "uniform int localPalette;\n"
445 "uniform ivec4 inflags;\n"
446 "uniform mat2x2 transform;\n"
447 "uniform ivec4 dims;\n"
448 "uniform ivec4 objwin;\n"
449 "uniform ivec4 mosaic;\n"
450 "OUT(0) out vec4 color;\n"
451 "OUT(1) out ivec4 flags;\n"
452 "OUT(2) out ivec4 window;\n"
453
454 "vec4 renderTile(int tile, int paletteId, ivec2 localCoord);\n"
455
456 "void main() {\n"
457 " vec2 incoord = texCoord;\n"
458 " if (mosaic.x > 1) {\n"
459 " int x = int(incoord.x);\n"
460 " incoord.x = float(clamp(x - (mosaic.z + x) % mosaic.x, 0, dims.z - 1));\n"
461 " } else if (mosaic.x < -1) {\n"
462 " int x = dims.z - int(incoord.x) - 1;\n"
463 " incoord.x = float(clamp(dims.z - x + (mosaic.z + x) % -mosaic.x - 1, 0, dims.z - 1));\n"
464 " }\n"
465 " if (mosaic.y > 1) {\n"
466 " int y = int(incoord.y);\n"
467 " incoord.y = float(clamp(y - (mosaic.w + y) % mosaic.y, 0, dims.w - 1));\n"
468 " }\n"
469 " ivec2 coord = ivec2(transform * (incoord - vec2(dims.zw) / 2.) + vec2(dims.xy) / 2.);\n"
470 " if ((coord & ~(dims.xy - 1)) != ivec2(0, 0)) {\n"
471 " discard;\n"
472 " }\n"
473 " vec4 pix = renderTile((coord.x >> 3) + (coord.y >> 3) * stride, localPalette, coord & 7);\n"
474 " color = pix;\n"
475 " flags = inflags;\n"
476 " gl_FragDepth = float(flags.x) / 16.;\n"
477 " window = ivec4(objwin.yzw, 0);\n"
478 "}";
479
480static const struct GBAVideoGLUniform _uniformsObjPriority[] = {
481 { "loc", GBA_GL_VS_LOC, },
482 { "maxPos", GBA_GL_VS_MAXPOS, },
483 { "inflags", GBA_GL_OBJ_INFLAGS, },
484 { 0 }
485};
486
487static const char* const _renderObjPriority =
488 "in vec2 texCoord;\n"
489 "uniform ivec4 inflags;\n"
490 "OUT(0) out vec4 color;\n"
491 "OUT(1) out ivec4 flags;\n"
492
493 "void main() {\n"
494 " flags = inflags;\n"
495 " gl_FragDepth = float(flags.x) / 16.;\n"
496 " color = vec4(0., 0., 0., 0.);"
497 "}";
498
499static const struct GBAVideoGLUniform _uniformsWindow[] = {
500 { "loc", GBA_GL_VS_LOC, },
501 { "maxPos", GBA_GL_VS_MAXPOS, },
502 { "dispcnt", GBA_GL_WIN_DISPCNT, },
503 { "blend", GBA_GL_WIN_BLEND, },
504 { "flags", GBA_GL_WIN_FLAGS, },
505 { "win0", GBA_GL_WIN_WIN0, },
506 { "win1", GBA_GL_WIN_WIN1, },
507 { 0 }
508};
509
510static const char* const _renderWindow =
511 "in vec2 texCoord;\n"
512 "uniform int dispcnt;\n"
513 "uniform ivec2 blend;\n"
514 "uniform ivec3 flags;\n"
515 "uniform ivec4 win0[160];\n"
516 "uniform ivec4 win1[160];\n"
517 "OUT(0) out ivec4 window;\n"
518
519 "bool crop(vec4 windowParams) {\n"
520 " bvec4 compare = lessThan(texCoord.xxyy, windowParams);\n"
521 " compare = equal(compare, bvec4(true, false, true, false));\n"
522 " if (any(compare)) {\n"
523 " vec2 h = windowParams.xy;\n"
524 " vec2 v = windowParams.zw;\n"
525 " if (v.x > v.y) {\n"
526 " if (compare.z && compare.w) {\n"
527 " return false;\n"
528 " }\n"
529 " } else if (compare.z || compare.w) {\n"
530 " return false;\n"
531 " }\n"
532 " if (h.x > h.y) {\n"
533 " if (compare.x && compare.y) {\n"
534 " return false;\n"
535 " }\n"
536 " } else if (compare.x || compare.y) {\n"
537 " return false;\n"
538 " }\n"
539 " }\n"
540 " return true;\n"
541 "}\n"
542
543 "vec4 interpolate(vec4 top, vec4 bottom) {\n"
544 " if (distance(top, bottom) > 40.) {\n"
545 " return top;\n"
546 " }\n"
547 " return vec4(mix(bottom.xy, top.xy, fract(texCoord.y)), top.zw);\n"
548 "}\n"
549
550 "void main() {\n"
551 " int dispflags = (dispcnt & 0x1F) | 0x20;\n"
552 " if ((dispcnt & 0xE0) == 0) {\n"
553 " window = ivec4(dispflags, blend, 0);\n"
554 " } else {\n"
555 " ivec4 windowFlags = ivec4(flags.z, blend, 0);\n"
556 " int top = int(texCoord.y);\n"
557 " int bottom = max(top - 1, 0);\n"
558 " if ((dispcnt & 0x20) != 0 && crop(interpolate(vec4(win0[top]), vec4(win0[bottom])))) { \n"
559 " windowFlags.x = flags.x;\n"
560 " } else if ((dispcnt & 0x40) != 0 && crop(interpolate(vec4(win1[top]), vec4(win1[bottom])))) {\n"
561 " windowFlags.x = flags.y;\n"
562 " }\n"
563 " window = windowFlags;\n"
564 " }\n"
565 "}\n";
566
567static const struct GBAVideoGLUniform _uniformsFinalize[] = {
568 { "loc", GBA_GL_VS_LOC, },
569 { "maxPos", GBA_GL_VS_MAXPOS, },
570 { "scale", GBA_GL_FINALIZE_SCALE, },
571 { "layers", GBA_GL_FINALIZE_LAYERS, },
572 { "flags", GBA_GL_FINALIZE_FLAGS, },
573 { "window", GBA_GL_FINALIZE_WINDOW, },
574 { "backdrop", GBA_GL_FINALIZE_BACKDROP, },
575 { "backdropFlags", GBA_GL_FINALIZE_BACKDROPFLAGS, },
576 { 0 }
577};
578
579static const char* const _finalize =
580 "in vec2 texCoord;\n"
581 "uniform int scale;\n"
582 "uniform sampler2D layers[5];\n"
583 "uniform isampler2D flags[5];\n"
584 "uniform isampler2D window;\n"
585 "uniform sampler2D backdrop;\n"
586 "uniform isampler2D backdropFlags;\n"
587 "out vec4 color;\n"
588
589 "void composite(vec4 pixel, ivec4 flags, inout vec4 topPixel, inout ivec4 topFlags, inout vec4 bottomPixel, inout ivec4 bottomFlags) {\n"
590 " if (flags.x >= topFlags.x) {\n"
591 " if (flags.x >= bottomFlags.x) {\n"
592 " return;\n"
593 " }\n"
594 " bottomFlags = flags;\n"
595 " bottomPixel = pixel;\n"
596 " } else {\n"
597 " bottomFlags = topFlags;\n"
598 " topFlags = flags;\n"
599 " bottomPixel = topPixel;\n"
600 " topPixel = pixel;\n"
601 " }\n"
602 "}\n"
603
604 "void main() {\n"
605 " vec4 topPixel = texelFetch(backdrop, ivec2(0, texCoord.y), 0);\n"
606 " vec4 bottomPixel = topPixel;\n"
607 " ivec4 topFlags = ivec4(texelFetch(backdropFlags, ivec2(0, texCoord.y), 0));\n"
608 " ivec4 bottomFlags = topFlags;\n"
609 " ivec2 coord = ivec2(texCoord * float(scale));\n"
610 " ivec4 windowFlags = texelFetch(window, coord, 0);\n"
611 " int layerWindow = windowFlags.x;\n"
612 " if ((layerWindow & 16) != 0) {\n"
613 " vec4 pix = texelFetch(layers[4], coord, 0);\n"
614 " if (pix.a != 0.) {\n"
615 " ivec4 inflags = ivec4(texelFetch(flags[4], coord, 0));\n"
616 " composite(pix, inflags, topPixel, topFlags, bottomPixel, bottomFlags);\n"
617 " }\n"
618 " }\n"
619 " if ((layerWindow & 1) != 0) {\n"
620 " vec4 pix = texelFetch(layers[0], coord, 0);\n"
621 " if (pix.a != 0.) {\n"
622 " ivec4 inflags = ivec4(texelFetch(flags[0], coord, 0).xyz, 0);\n"
623 " composite(pix, inflags, topPixel, topFlags, bottomPixel, bottomFlags);\n"
624 " }\n"
625 " }\n"
626 " if ((layerWindow & 2) != 0) {\n"
627 " vec4 pix = texelFetch(layers[1], coord, 0);\n"
628 " if (pix.a != 0.) {\n"
629 " ivec4 inflags = ivec4(texelFetch(flags[1], coord, 0).xyz, 0);\n"
630 " composite(pix, inflags, topPixel, topFlags, bottomPixel, bottomFlags);\n"
631 " }\n"
632 " }\n"
633 " if ((layerWindow & 4) != 0) {\n"
634 " vec4 pix = texelFetch(layers[2], coord, 0);\n"
635 " if (pix.a != 0.) {\n"
636 " ivec4 inflags = ivec4(texelFetch(flags[2], coord, 0).xyz, 0);\n"
637 " composite(pix, inflags, topPixel, topFlags, bottomPixel, bottomFlags);\n"
638 " }\n"
639 " }\n"
640 " if ((layerWindow & 8) != 0) {\n"
641 " vec4 pix = texelFetch(layers[3], coord, 0);\n"
642 " if (pix.a != 0.) {\n"
643 " ivec4 inflags = ivec4(texelFetch(flags[3], coord, 0).xyz, 0);\n"
644 " composite(pix, inflags, topPixel, topFlags, bottomPixel, bottomFlags);\n"
645 " }\n"
646 " }\n"
647 " if ((layerWindow & 32) == 0) {\n"
648 " topFlags.y &= ~1;\n"
649 " }\n"
650 " if (((topFlags.y & 13) == 5 || topFlags.w > 0) && (bottomFlags.y & 2) == 2) {\n"
651 " topPixel.rgb *= float(topFlags.z) / 16.;\n"
652 " topPixel.rgb += bottomPixel.rgb * float(windowFlags.y) / 16.;\n"
653 " } else if ((topFlags.y & 13) == 9) {\n"
654 " topPixel.rgb += (1. - topPixel.rgb) * float(windowFlags.z) / 16.;\n"
655 " } else if ((topFlags.y & 13) == 13) {\n"
656 " topPixel.rgb -= topPixel.rgb * float(windowFlags.z) / 16.;\n"
657 " }\n"
658 " color = topPixel;\n"
659 "}";
660
661static const GLint _vertices[] = {
662 0, 0,
663 0, 1,
664 1, 1,
665 1, 0,
666};
667
668void GBAVideoGLRendererCreate(struct GBAVideoGLRenderer* renderer) {
669 renderer->d.init = GBAVideoGLRendererInit;
670 renderer->d.reset = GBAVideoGLRendererReset;
671 renderer->d.deinit = GBAVideoGLRendererDeinit;
672 renderer->d.writeVideoRegister = GBAVideoGLRendererWriteVideoRegister;
673 renderer->d.writeVRAM = GBAVideoGLRendererWriteVRAM;
674 renderer->d.writeOAM = GBAVideoGLRendererWriteOAM;
675 renderer->d.writePalette = GBAVideoGLRendererWritePalette;
676 renderer->d.drawScanline = GBAVideoGLRendererDrawScanline;
677 renderer->d.finishFrame = GBAVideoGLRendererFinishFrame;
678 renderer->d.getPixels = GBAVideoGLRendererGetPixels;
679 renderer->d.putPixels = GBAVideoGLRendererPutPixels;
680
681 renderer->d.disableBG[0] = false;
682 renderer->d.disableBG[1] = false;
683 renderer->d.disableBG[2] = false;
684 renderer->d.disableBG[3] = false;
685 renderer->d.disableOBJ = false;
686
687 renderer->d.highlightBG[0] = false;
688 renderer->d.highlightBG[1] = false;
689 renderer->d.highlightBG[2] = false;
690 renderer->d.highlightBG[3] = false;
691 int i;
692 for (i = 0; i < 128; ++i) {
693 renderer->d.highlightOBJ[i] = false;
694 }
695 renderer->d.highlightColor = 0xFFFFFF;
696 renderer->d.highlightAmount = 0;
697
698 renderer->scale = 1;
699}
700
701static void _compileShader(struct GBAVideoGLRenderer* glRenderer, struct GBAVideoGLShader* shader, const char** shaderBuffer, int shaderBufferLines, GLuint vs, const struct GBAVideoGLUniform* uniforms, const char* const* outFrags, char* log) {
702 GLuint program = glCreateProgram();
703 shader->program = program;
704
705 GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
706 glAttachShader(program, vs);
707 glAttachShader(program, fs);
708 glShaderSource(fs, shaderBufferLines, shaderBuffer, 0);
709 glCompileShader(fs);
710 glGetShaderInfoLog(fs, 2048, 0, log);
711 if (log[0]) {
712 mLOG(GBA_VIDEO, ERROR, "Fragment shader compilation failure: %s", log);
713 }
714 size_t i;
715#ifndef BUILD_GLES3
716 for (i = 0; outFrags[i]; ++i) {
717 glBindFragDataLocation(program, i, outFrags[i]);
718 }
719#else
720 UNUSED(outFrags);
721#endif
722 glLinkProgram(program);
723 glGetProgramInfoLog(program, 2048, 0, log);
724 if (log[0]) {
725 mLOG(GBA_VIDEO, ERROR, "Program link failure: %s", log);
726 }
727 glDeleteShader(fs);
728
729 glGenVertexArrays(1, &shader->vao);
730 glBindVertexArray(shader->vao);
731 glBindBuffer(GL_ARRAY_BUFFER, glRenderer->vbo);
732 GLuint positionLocation = glGetAttribLocation(program, "position");
733 glEnableVertexAttribArray(positionLocation);
734 glVertexAttribPointer(positionLocation, 2, GL_INT, GL_FALSE, 0, NULL);
735
736 for (i = 0; uniforms[i].name; ++i) {
737 shader->uniforms[uniforms[i].type] = glGetUniformLocation(program, uniforms[i].name);
738 }
739}
740
741static void _deleteShader(struct GBAVideoGLShader* shader) {
742 glDeleteProgram(shader->program);
743 glDeleteVertexArrays(1, &shader->vao);
744}
745
746static void _initFramebufferTextureEx(GLuint tex, GLenum internalFormat, GLenum format, GLenum type, GLenum attachment, int scale) {
747 glBindTexture(GL_TEXTURE_2D, tex);
748 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
749 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
750 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
751 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
752 glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, scale > 0 ? GBA_VIDEO_HORIZONTAL_PIXELS * scale : 1, GBA_VIDEO_VERTICAL_PIXELS * (scale > 0 ? scale : 1), 0, format, type, 0);
753 glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, tex, 0);
754}
755
756static void _initFramebufferTexture(GLuint tex, GLenum format, GLenum attachment, int scale) {
757 _initFramebufferTextureEx(tex, format, format, GL_UNSIGNED_BYTE, attachment, scale);
758}
759
760static void _initFramebuffers(struct GBAVideoGLRenderer* glRenderer) {
761 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_OBJ]);
762 _initFramebufferTexture(glRenderer->layers[GBA_GL_TEX_OBJ_COLOR], GL_RGBA, GL_COLOR_ATTACHMENT0, glRenderer->scale);
763 _initFramebufferTextureEx(glRenderer->layers[GBA_GL_TEX_OBJ_FLAGS], GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, GL_COLOR_ATTACHMENT1, glRenderer->scale);
764 _initFramebufferTextureEx(glRenderer->layers[GBA_GL_TEX_WINDOW], GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, GL_COLOR_ATTACHMENT2, glRenderer->scale);
765 _initFramebufferTextureEx(glRenderer->layers[GBA_GL_TEX_OBJ_DEPTH], GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH_STENCIL_ATTACHMENT, glRenderer->scale);
766
767 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_BACKDROP]);
768 _initFramebufferTexture(glRenderer->layers[GBA_GL_TEX_BACKDROP_COLOR], GL_RGB, GL_COLOR_ATTACHMENT0, 0);
769 _initFramebufferTextureEx(glRenderer->layers[GBA_GL_TEX_BACKDROP_FLAGS], GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, GL_COLOR_ATTACHMENT1, glRenderer->scale);
770
771 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_WINDOW]);
772 _initFramebufferTextureEx(glRenderer->layers[GBA_GL_TEX_WINDOW], GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, GL_COLOR_ATTACHMENT0, glRenderer->scale);
773
774 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_OUTPUT]);
775 _initFramebufferTexture(glRenderer->outputTex, GL_RGB, GL_COLOR_ATTACHMENT0, glRenderer->scale);
776
777 int i;
778 for (i = 0; i < 4; ++i) {
779 struct GBAVideoGLBackground* bg = &glRenderer->bg[i];
780 glBindFramebuffer(GL_FRAMEBUFFER, bg->fbo);
781 _initFramebufferTexture(bg->tex, GL_RGBA, GL_COLOR_ATTACHMENT0, glRenderer->scale);
782 _initFramebufferTextureEx(bg->flags, GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, GL_COLOR_ATTACHMENT1, glRenderer->scale);
783 }
784 glBindFramebuffer(GL_FRAMEBUFFER, 0);
785}
786
787void GBAVideoGLRendererInit(struct GBAVideoRenderer* renderer) {
788 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
789 glRenderer->temporaryBuffer = NULL;
790
791 glGenFramebuffers(GBA_GL_FBO_MAX, glRenderer->fbo);
792 glGenTextures(GBA_GL_TEX_MAX, glRenderer->layers);
793
794 glGenTextures(1, &glRenderer->vramTex);
795 glBindTexture(GL_TEXTURE_2D, glRenderer->vramTex);
796 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
797 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
798 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA4, 256, 192, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 0);
799
800 glGenBuffers(1, &glRenderer->vbo);
801 glBindBuffer(GL_ARRAY_BUFFER, glRenderer->vbo);
802 glBufferData(GL_ARRAY_BUFFER, sizeof(_vertices), _vertices, GL_STATIC_DRAW);
803
804 int i;
805 for (i = 0; i < 4; ++i) {
806 struct GBAVideoGLBackground* bg = &glRenderer->bg[i];
807 bg->index = i;
808 bg->enabled = 0;
809 bg->priority = 0;
810 bg->charBase = 0;
811 bg->mosaic = 0;
812 bg->multipalette = 0;
813 bg->screenBase = 0;
814 bg->overflow = 0;
815 bg->size = 0;
816 bg->target1 = 0;
817 bg->target2 = 0;
818 bg->x = 0;
819 bg->y = 0;
820 bg->refx = 0;
821 bg->refy = 0;
822 bg->affine.dx = 256;
823 bg->affine.dmx = 0;
824 bg->affine.dy = 0;
825 bg->affine.dmy = 256;
826 bg->affine.sx = 0;
827 bg->affine.sy = 0;
828 glGenFramebuffers(1, &bg->fbo);
829 glGenTextures(1, &bg->tex);
830 glGenTextures(1, &bg->flags);
831 }
832
833 _initFramebuffers(glRenderer);
834
835 char log[2048];
836 const GLchar* shaderBuffer[4];
837 const GLubyte* version = glGetString(GL_VERSION);
838 if (strncmp((const char*) version, "OpenGL ES ", strlen("OpenGL ES "))) {
839 shaderBuffer[0] = _gl3Header;
840 } else {
841 shaderBuffer[0] = _gles3Header;
842 }
843
844 GLuint vs = glCreateShader(GL_VERTEX_SHADER);
845 shaderBuffer[1] = _vertexShader;
846 glShaderSource(vs, 2, shaderBuffer, 0);
847 glCompileShader(vs);
848 glGetShaderInfoLog(vs, 2048, 0, log);
849 if (log[0]) {
850 mLOG(GBA_VIDEO, ERROR, "Vertex shader compilation failure: %s", log);
851 }
852
853 const char* const noWindow[] = {"color", "flags", NULL};
854 const char* const window[] = {"color", "flags", "window", NULL};
855 const char* const onlyWindow[] = {"window", NULL};
856 const char* const onlyColor[] = {"color", NULL};
857
858 shaderBuffer[1] = _renderMode0;
859
860 shaderBuffer[2] = _renderTile16;
861 _compileShader(glRenderer, &glRenderer->bgShader[0], shaderBuffer, 3, vs, _uniformsMode0, noWindow, log);
862
863 shaderBuffer[2] = _renderTile256;
864 _compileShader(glRenderer, &glRenderer->bgShader[1], shaderBuffer, 3, vs, _uniformsMode0, noWindow, log);
865
866 shaderBuffer[1] = _renderMode2;
867 shaderBuffer[2] = _interpolate;
868
869 shaderBuffer[3] = _fetchTileOverflow;
870 _compileShader(glRenderer, &glRenderer->bgShader[2], shaderBuffer, 4, vs, _uniformsMode2, noWindow, log);
871
872 shaderBuffer[3] = _fetchTileNoOverflow;
873 _compileShader(glRenderer, &glRenderer->bgShader[3], shaderBuffer, 4, vs, _uniformsMode2, noWindow, log);
874
875 shaderBuffer[1] = _renderMode4;
876 shaderBuffer[2] = _interpolate;
877 _compileShader(glRenderer, &glRenderer->bgShader[4], shaderBuffer, 3, vs, _uniformsMode4, noWindow, log);
878
879 shaderBuffer[1] = _renderMode35;
880 shaderBuffer[2] = _interpolate;
881 _compileShader(glRenderer, &glRenderer->bgShader[5], shaderBuffer, 3, vs, _uniformsMode35, noWindow, log);
882
883 shaderBuffer[1] = _renderObj;
884
885 shaderBuffer[2] = _renderTile16;
886 _compileShader(glRenderer, &glRenderer->objShader[0], shaderBuffer, 3, vs, _uniformsObj, window, log);
887
888 shaderBuffer[2] = _renderTile256;
889 _compileShader(glRenderer, &glRenderer->objShader[1], shaderBuffer, 3, vs, _uniformsObj, window, log);
890
891 shaderBuffer[1] = _renderObjPriority;
892 _compileShader(glRenderer, &glRenderer->objShader[2], shaderBuffer, 2, vs, _uniformsObjPriority, noWindow, log);
893
894 shaderBuffer[1] = _renderWindow;
895 _compileShader(glRenderer, &glRenderer->windowShader, shaderBuffer, 2, vs, _uniformsWindow, onlyWindow, log);
896
897 shaderBuffer[1] = _finalize;
898 _compileShader(glRenderer, &glRenderer->finalizeShader, shaderBuffer, 2, vs, _uniformsFinalize, onlyColor, log);
899
900 glBindVertexArray(0);
901 glDeleteShader(vs);
902
903 GBAVideoGLRendererReset(renderer);
904}
905
906void GBAVideoGLRendererDeinit(struct GBAVideoRenderer* renderer) {
907 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
908 if (glRenderer->temporaryBuffer) {
909 mappedMemoryFree(glRenderer->temporaryBuffer, GBA_VIDEO_HORIZONTAL_PIXELS * GBA_VIDEO_VERTICAL_PIXELS * glRenderer->scale * glRenderer->scale);
910 }
911 glDeleteFramebuffers(GBA_GL_FBO_MAX, glRenderer->fbo);
912 glDeleteTextures(GBA_GL_TEX_MAX, glRenderer->layers);
913 glDeleteTextures(1, &glRenderer->vramTex);
914 glDeleteBuffers(1, &glRenderer->vbo);
915
916 _deleteShader(&glRenderer->bgShader[0]);
917 _deleteShader(&glRenderer->bgShader[1]);
918 _deleteShader(&glRenderer->bgShader[2]);
919 _deleteShader(&glRenderer->bgShader[3]);
920 _deleteShader(&glRenderer->objShader[0]);
921 _deleteShader(&glRenderer->objShader[1]);
922 _deleteShader(&glRenderer->objShader[2]);
923 _deleteShader(&glRenderer->finalizeShader);
924
925 int i;
926 for (i = 0; i < 4; ++i) {
927 struct GBAVideoGLBackground* bg = &glRenderer->bg[i];
928 glDeleteFramebuffers(1, &bg->fbo);
929 glDeleteTextures(1, &bg->tex);
930 glDeleteTextures(1, &bg->flags);
931 }
932}
933
934void GBAVideoGLRendererReset(struct GBAVideoRenderer* renderer) {
935 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
936
937 glRenderer->oamDirty = true;
938 glRenderer->paletteDirty = true;
939 glRenderer->vramDirty = 0xFFFFFF;
940 glRenderer->firstAffine = -1;
941 glRenderer->firstY = -1;
942 glRenderer->dispcnt = 0x0080;
943 glRenderer->mosaic = 0;
944 memset(glRenderer->shadowRegs, 0, sizeof(glRenderer->shadowRegs));
945 glRenderer->regsDirty = 0xFFFFFFFFFFFEULL;
946}
947
948void GBAVideoGLRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address) {
949 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
950 glRenderer->vramDirty |= 1 << (address >> 12);
951}
952
953void GBAVideoGLRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam) {
954 UNUSED(oam);
955 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
956 glRenderer->oamDirty = true;
957}
958
959void GBAVideoGLRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
960 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
961 UNUSED(address);
962 UNUSED(value);
963 glRenderer->paletteDirty = true;
964}
965
966uint16_t GBAVideoGLRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
967 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
968 if (renderer->cache) {
969 GBAVideoCacheWriteVideoRegister(renderer->cache, address, value);
970 }
971
972 bool dirty = false;
973 switch (address) {
974 case REG_DISPCNT:
975 value &= 0xFFF7;
976 dirty = true;
977 break;
978 case REG_BG0CNT:
979 case REG_BG1CNT:
980 value &= 0xDFFF;
981 dirty = true;
982 break;
983 case REG_BG0HOFS:
984 value &= 0x01FF;
985 glRenderer->bg[0].x = value;
986 dirty = false;
987 break;
988 case REG_BG0VOFS:
989 value &= 0x01FF;
990 glRenderer->bg[0].y = value;
991 dirty = false;
992 break;
993 case REG_BG1HOFS:
994 value &= 0x01FF;
995 glRenderer->bg[1].x = value;
996 dirty = false;
997 break;
998 case REG_BG1VOFS:
999 value &= 0x01FF;
1000 glRenderer->bg[1].y = value;
1001 dirty = false;
1002 break;
1003 case REG_BG2HOFS:
1004 value &= 0x01FF;
1005 glRenderer->bg[2].x = value;
1006 dirty = false;
1007 break;
1008 case REG_BG2VOFS:
1009 value &= 0x01FF;
1010 glRenderer->bg[2].y = value;
1011 dirty = false;
1012 break;
1013 case REG_BG3HOFS:
1014 value &= 0x01FF;
1015 glRenderer->bg[3].x = value;
1016 dirty = false;
1017 break;
1018 case REG_BG3VOFS:
1019 value &= 0x01FF;
1020 glRenderer->bg[3].y = value;
1021 dirty = false;
1022 break;
1023 case REG_BG2PA:
1024 glRenderer->bg[2].affine.dx = value;
1025 break;
1026 case REG_BG2PB:
1027 glRenderer->bg[2].affine.dmx = value;
1028 break;
1029 case REG_BG2PC:
1030 glRenderer->bg[2].affine.dy = value;
1031 break;
1032 case REG_BG2PD:
1033 glRenderer->bg[2].affine.dmy = value;
1034 break;
1035 case REG_BG2X_LO:
1036 GBAVideoGLRendererWriteBGX_LO(&glRenderer->bg[2], value);
1037 break;
1038 case REG_BG2X_HI:
1039 GBAVideoGLRendererWriteBGX_HI(&glRenderer->bg[2], value);
1040 break;
1041 case REG_BG2Y_LO:
1042 GBAVideoGLRendererWriteBGY_LO(&glRenderer->bg[2], value);
1043 break;
1044 case REG_BG2Y_HI:
1045 GBAVideoGLRendererWriteBGY_HI(&glRenderer->bg[2], value);
1046 break;
1047 case REG_BG3PA:
1048 glRenderer->bg[3].affine.dx = value;
1049 break;
1050 case REG_BG3PB:
1051 glRenderer->bg[3].affine.dmx = value;
1052 break;
1053 case REG_BG3PC:
1054 glRenderer->bg[3].affine.dy = value;
1055 break;
1056 case REG_BG3PD:
1057 glRenderer->bg[3].affine.dmy = value;
1058 break;
1059 case REG_BG3X_LO:
1060 GBAVideoGLRendererWriteBGX_LO(&glRenderer->bg[3], value);
1061 break;
1062 case REG_BG3X_HI:
1063 GBAVideoGLRendererWriteBGX_HI(&glRenderer->bg[3], value);
1064 break;
1065 case REG_BG3Y_LO:
1066 GBAVideoGLRendererWriteBGY_LO(&glRenderer->bg[3], value);
1067 break;
1068 case REG_BG3Y_HI:
1069 GBAVideoGLRendererWriteBGY_HI(&glRenderer->bg[3], value);
1070 break;
1071 case REG_BLDALPHA:
1072 value &= 0x1F1F;
1073 dirty = true;
1074 break;
1075 case REG_BLDY:
1076 value &= 0x1F;
1077 if (value > 0x10) {
1078 value = 0x10;
1079 }
1080 dirty = true;
1081 break;
1082 case REG_WIN0H:
1083 glRenderer->winN[0].h.end = value;
1084 glRenderer->winN[0].h.start = value >> 8;
1085 if (glRenderer->winN[0].h.start > GBA_VIDEO_HORIZONTAL_PIXELS && glRenderer->winN[0].h.start > glRenderer->winN[0].h.end) {
1086 glRenderer->winN[0].h.start = 0;
1087 }
1088 if (glRenderer->winN[0].h.end > GBA_VIDEO_HORIZONTAL_PIXELS) {
1089 glRenderer->winN[0].h.end = GBA_VIDEO_HORIZONTAL_PIXELS;
1090 if (glRenderer->winN[0].h.start > GBA_VIDEO_HORIZONTAL_PIXELS) {
1091 glRenderer->winN[0].h.start = GBA_VIDEO_HORIZONTAL_PIXELS;
1092 }
1093 }
1094 break;
1095 case REG_WIN1H:
1096 glRenderer->winN[1].h.end = value;
1097 glRenderer->winN[1].h.start = value >> 8;
1098 if (glRenderer->winN[1].h.start > GBA_VIDEO_HORIZONTAL_PIXELS && glRenderer->winN[1].h.start > glRenderer->winN[1].h.end) {
1099 glRenderer->winN[1].h.start = 0;
1100 }
1101 if (glRenderer->winN[1].h.end > GBA_VIDEO_HORIZONTAL_PIXELS) {
1102 glRenderer->winN[1].h.end = GBA_VIDEO_HORIZONTAL_PIXELS;
1103 if (glRenderer->winN[1].h.start > GBA_VIDEO_HORIZONTAL_PIXELS) {
1104 glRenderer->winN[1].h.start = GBA_VIDEO_HORIZONTAL_PIXELS;
1105 }
1106 }
1107 break;
1108 case REG_WIN0V:
1109 glRenderer->winN[0].v.end = value;
1110 glRenderer->winN[0].v.start = value >> 8;
1111 if (glRenderer->winN[0].v.start > GBA_VIDEO_VERTICAL_PIXELS && glRenderer->winN[0].v.start > glRenderer->winN[0].v.end) {
1112 glRenderer->winN[0].v.start = 0;
1113 }
1114 if (glRenderer->winN[0].v.end > GBA_VIDEO_VERTICAL_PIXELS) {
1115 glRenderer->winN[0].v.end = GBA_VIDEO_VERTICAL_PIXELS;
1116 if (glRenderer->winN[0].v.start > GBA_VIDEO_VERTICAL_PIXELS) {
1117 glRenderer->winN[0].v.start = GBA_VIDEO_VERTICAL_PIXELS;
1118 }
1119 }
1120 break;
1121 case REG_WIN1V:
1122 glRenderer->winN[1].v.end = value;
1123 glRenderer->winN[1].v.start = value >> 8;
1124 if (glRenderer->winN[1].v.start > GBA_VIDEO_VERTICAL_PIXELS && glRenderer->winN[1].v.start > glRenderer->winN[1].v.end) {
1125 glRenderer->winN[1].v.start = 0;
1126 }
1127 if (glRenderer->winN[1].v.end > GBA_VIDEO_VERTICAL_PIXELS) {
1128 glRenderer->winN[1].v.end = GBA_VIDEO_VERTICAL_PIXELS;
1129 if (glRenderer->winN[1].v.start > GBA_VIDEO_VERTICAL_PIXELS) {
1130 glRenderer->winN[1].v.start = GBA_VIDEO_VERTICAL_PIXELS;
1131 }
1132 }
1133 break;
1134 case REG_WININ:
1135 case REG_WINOUT:
1136 value &= 0x3F3F;
1137 dirty = true;
1138 break;
1139 default:
1140 dirty = true;
1141 break;
1142 }
1143 if (glRenderer->shadowRegs[address >> 1] == value) {
1144 dirty = false;
1145 } else {
1146 glRenderer->shadowRegs[address >> 1] = value;
1147 }
1148 if (dirty) {
1149 glRenderer->regsDirty |= 1ULL << (address >> 1);
1150 }
1151 return value;
1152}
1153
1154void _cleanRegister(struct GBAVideoGLRenderer* glRenderer, int address, uint16_t value) {
1155 switch (address) {
1156 case REG_DISPCNT:
1157 glRenderer->dispcnt = value;
1158 GBAVideoGLRendererUpdateDISPCNT(glRenderer);
1159 break;
1160 case REG_BG0CNT:
1161 GBAVideoGLRendererWriteBGCNT(&glRenderer->bg[0], value);
1162 break;
1163 case REG_BG1CNT:
1164 GBAVideoGLRendererWriteBGCNT(&glRenderer->bg[1], value);
1165 break;
1166 case REG_BG2CNT:
1167 GBAVideoGLRendererWriteBGCNT(&glRenderer->bg[2], value);
1168 break;
1169 case REG_BG3CNT:
1170 GBAVideoGLRendererWriteBGCNT(&glRenderer->bg[3], value);
1171 break;
1172 case REG_BLDCNT:
1173 GBAVideoGLRendererWriteBLDCNT(glRenderer, value);
1174 break;
1175 case REG_BLDALPHA:
1176 glRenderer->blda = value & 0x1F;
1177 if (glRenderer->blda > 0x10) {
1178 glRenderer->blda = 0x10;
1179 }
1180 glRenderer->bldb = (value >> 8) & 0x1F;
1181 if (glRenderer->bldb > 0x10) {
1182 glRenderer->bldb = 0x10;
1183 }
1184 break;
1185 case REG_BLDY:
1186 glRenderer->bldy = value;
1187 break;
1188 case REG_WININ:
1189 glRenderer->winN[0].control = value;
1190 glRenderer->winN[1].control = value >> 8;
1191 break;
1192 case REG_WINOUT:
1193 glRenderer->winout = value;
1194 glRenderer->objwin = value >> 8;
1195 break;
1196 case REG_MOSAIC:
1197 glRenderer->mosaic = value;
1198 break;
1199 default:
1200 break;
1201 }
1202}
1203
1204static bool _dirtyMode0(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1205 UNUSED(y);
1206 if (!background->enabled) {
1207 return false;
1208 }
1209 unsigned screenBase = background->screenBase >> 11; // Lops off one extra bit
1210 unsigned screenMask = (7 << screenBase) & 0xFFFF; // Technically overzealous
1211 if (renderer->vramDirty & screenMask) {
1212 return true;
1213 }
1214 unsigned charBase = background->charBase >> 11;
1215 unsigned charMask = (0xFFFF << charBase) & 0xFFFF;
1216 if (renderer->vramDirty & charMask) {
1217 return true;
1218 }
1219 return false;
1220}
1221
1222static bool _dirtyMode2(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1223 UNUSED(y);
1224 if (!background->enabled) {
1225 return false;
1226 }
1227 unsigned screenBase = background->screenBase >> 11; // Lops off one extra bit
1228 unsigned screenMask = (0xF << screenBase) & 0xFFFF;
1229 if (renderer->vramDirty & screenMask) {
1230 return true;
1231 }
1232 unsigned charBase = background->charBase >> 11;
1233 unsigned charMask = (0x3FFF << charBase) & 0xFFFF;
1234 if (renderer->vramDirty & charMask) {
1235 return true;
1236 }
1237 return false;
1238}
1239
1240static bool _dirtyMode3(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1241 UNUSED(y);
1242 if (!background->enabled) {
1243 return false;
1244 }
1245 if (renderer->vramDirty & 0xFFFFF) {
1246 return true;
1247 }
1248 return false;
1249}
1250
1251static bool _dirtyMode45(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1252 UNUSED(y);
1253 if (!background->enabled) {
1254 return false;
1255 }
1256 int start = GBARegisterDISPCNTIsFrameSelect(renderer->dispcnt) ? 5 : 0;
1257 int mask = 0x3FF << start;
1258 if (renderer->vramDirty & mask) {
1259 return true;
1260 }
1261 return false;
1262}
1263
1264static bool _needsVramUpload(struct GBAVideoGLRenderer* renderer, int y) {
1265 if (!renderer->vramDirty) {
1266 return false;
1267 }
1268 if (y == 0) {
1269 return true;
1270 }
1271
1272 if (GBARegisterDISPCNTIsObjEnable(renderer->dispcnt) && renderer->vramDirty & 0xFF0000) {
1273 return true;
1274 }
1275
1276 bool dirty = false;
1277 switch (GBARegisterDISPCNTGetMode(renderer->dispcnt)) {
1278 case 0:
1279 dirty = dirty || _dirtyMode0(renderer, &renderer->bg[0], y);
1280 dirty = dirty || _dirtyMode0(renderer, &renderer->bg[1], y);
1281 dirty = dirty || _dirtyMode0(renderer, &renderer->bg[2], y);
1282 dirty = dirty || _dirtyMode0(renderer, &renderer->bg[3], y);
1283 break;
1284 case 1:
1285 dirty = dirty || _dirtyMode0(renderer, &renderer->bg[0], y);
1286 dirty = dirty || _dirtyMode0(renderer, &renderer->bg[1], y);
1287 dirty = dirty || _dirtyMode2(renderer, &renderer->bg[2], y);
1288 break;
1289 case 2:
1290 dirty = dirty || _dirtyMode2(renderer, &renderer->bg[2], y);
1291 dirty = dirty || _dirtyMode2(renderer, &renderer->bg[3], y);
1292 break;
1293 case 3:
1294 dirty = _dirtyMode3(renderer, &renderer->bg[2], y);
1295 break;
1296 case 4:
1297 dirty = _dirtyMode45(renderer, &renderer->bg[2], y);
1298 break;
1299 case 5:
1300 dirty = _dirtyMode45(renderer, &renderer->bg[2], y);
1301 break;
1302 }
1303 return dirty;
1304}
1305
1306void GBAVideoGLRendererDrawScanline(struct GBAVideoRenderer* renderer, int y) {
1307 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
1308
1309 if (GBARegisterDISPCNTGetMode(glRenderer->dispcnt) != 0) {
1310 if (glRenderer->firstAffine < 0) {
1311 glRenderer->firstAffine = y;
1312 }
1313 } else {
1314 glRenderer->firstAffine = -1;
1315 }
1316
1317 if (glRenderer->paletteDirty || _needsVramUpload(glRenderer, y) || glRenderer->oamDirty || glRenderer->regsDirty) {
1318 if (glRenderer->firstY >= 0) {
1319 _drawScanlines(glRenderer, y - 1);
1320 glBindVertexArray(0);
1321 }
1322 }
1323 if (glRenderer->firstY < 0) {
1324 glRenderer->firstY = y;
1325 }
1326
1327 int i;
1328 for (i = 0; i < 0x30; ++i) {
1329 if (!(glRenderer->regsDirty & (1ULL << i))) {
1330 continue;
1331 }
1332 _cleanRegister(glRenderer, i << 1, glRenderer->shadowRegs[i]);
1333 }
1334 glRenderer->regsDirty = 0;
1335
1336 glRenderer->winNHistory[0][y * 4 + 0] = glRenderer->winN[0].h.start;
1337 glRenderer->winNHistory[0][y * 4 + 1] = glRenderer->winN[0].h.end;
1338 glRenderer->winNHistory[0][y * 4 + 2] = glRenderer->winN[0].v.start;
1339 glRenderer->winNHistory[0][y * 4 + 3] = glRenderer->winN[0].v.end;
1340 glRenderer->winNHistory[1][y * 4 + 0] = glRenderer->winN[1].h.start;
1341 glRenderer->winNHistory[1][y * 4 + 1] = glRenderer->winN[1].h.end;
1342 glRenderer->winNHistory[1][y * 4 + 2] = glRenderer->winN[1].v.start;
1343 glRenderer->winNHistory[1][y * 4 + 3] = glRenderer->winN[1].v.end;
1344
1345 glRenderer->bg[0].scanlineOffset[y] = glRenderer->bg[0].x;
1346 glRenderer->bg[0].scanlineOffset[y] |= glRenderer->bg[0].y << 12;
1347 glRenderer->bg[1].scanlineOffset[y] = glRenderer->bg[1].x;
1348 glRenderer->bg[1].scanlineOffset[y] |= glRenderer->bg[1].y << 12;
1349 glRenderer->bg[2].scanlineOffset[y] = glRenderer->bg[2].x;
1350 glRenderer->bg[2].scanlineOffset[y] |= glRenderer->bg[2].y << 12;
1351 glRenderer->bg[2].scanlineAffine[y * 4] = glRenderer->bg[2].affine.dx;
1352 glRenderer->bg[2].scanlineAffine[y * 4 + 1] = glRenderer->bg[2].affine.dy;
1353 glRenderer->bg[2].scanlineAffine[y * 4 + 2] = glRenderer->bg[2].affine.sx;
1354 glRenderer->bg[2].scanlineAffine[y * 4 + 3] = glRenderer->bg[2].affine.sy;
1355 glRenderer->bg[3].scanlineOffset[y] = glRenderer->bg[3].x;
1356 glRenderer->bg[3].scanlineOffset[y] |= glRenderer->bg[3].y << 12;
1357 glRenderer->bg[3].scanlineAffine[y * 4] = glRenderer->bg[3].affine.dx;
1358 glRenderer->bg[3].scanlineAffine[y * 4 + 1] = glRenderer->bg[3].affine.dy;
1359 glRenderer->bg[3].scanlineAffine[y * 4 + 2] = glRenderer->bg[3].affine.sx;
1360 glRenderer->bg[3].scanlineAffine[y * 4 + 3] = glRenderer->bg[3].affine.sy;
1361
1362 if (glRenderer->paletteDirty) {
1363 for (i = 0; i < 512; ++i) {
1364 glRenderer->shadowPalette[i] = glRenderer->d.palette[i];
1365 }
1366 glRenderer->paletteDirty = false;
1367 }
1368
1369 if (_needsVramUpload(glRenderer, y)) {
1370 int first = -1;
1371 glBindTexture(GL_TEXTURE_2D, glRenderer->vramTex);
1372 for (i = 0; i < 25; ++i) {
1373 if (!(glRenderer->vramDirty & (1 << i))) {
1374 if (first >= 0) {
1375 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 8 * first, 256, 8 * (i - first), GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, &glRenderer->d.vram[2048 * first]);
1376 first = -1;
1377 }
1378 } else if (first < 0) {
1379 first = i;
1380 }
1381 }
1382 glRenderer->vramDirty = 0;
1383 }
1384
1385 if (glRenderer->oamDirty) {
1386 glRenderer->oamMax = GBAVideoRendererCleanOAM(glRenderer->d.oam->obj, glRenderer->sprites, 0);
1387 glRenderer->oamDirty = false;
1388 }
1389
1390 if (y == 0) {
1391 glDisable(GL_SCISSOR_TEST);
1392 glClearColor(0, 0, 0, 0);
1393#ifdef BUILD_GLES3
1394 glClearDepthf(1.f);
1395#else
1396 glClearDepth(1);
1397#endif
1398 glClearStencil(0);
1399 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_OBJ]);
1400 glDrawBuffers(2, (GLenum[]) { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 });
1401 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
1402
1403 for (i = 0; i < 4; ++i) {
1404 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->bg[i].fbo);
1405 glDrawBuffers(2, (GLenum[]) { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 });
1406 glClear(GL_COLOR_BUFFER_BIT);
1407 }
1408 }
1409
1410 if (GBARegisterDISPCNTGetMode(glRenderer->dispcnt) != 0) {
1411 glRenderer->bg[2].affine.sx += glRenderer->bg[2].affine.dmx;
1412 glRenderer->bg[2].affine.sy += glRenderer->bg[2].affine.dmy;
1413 glRenderer->bg[3].affine.sx += glRenderer->bg[3].affine.dmx;
1414 glRenderer->bg[3].affine.sy += glRenderer->bg[3].affine.dmy;
1415 }
1416}
1417
1418void _drawScanlines(struct GBAVideoGLRenderer* glRenderer, int y) {
1419 glEnable(GL_SCISSOR_TEST);
1420
1421 uint32_t backdrop = M_RGB5_TO_RGB8(glRenderer->shadowPalette[0]);
1422 glViewport(0, 0, 1, GBA_VIDEO_VERTICAL_PIXELS);
1423 glScissor(0, glRenderer->firstY, 1, y - glRenderer->firstY + 1);
1424 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_BACKDROP]);
1425 glDrawBuffers(2, (GLenum[]) { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 });
1426 glClearBufferfv(GL_COLOR, 0, (GLfloat[]) { ((backdrop >> 16) & 0xF8) / 248., ((backdrop >> 8) & 0xF8) / 248., (backdrop & 0xF8) / 248., 1.f });
1427 glClearBufferiv(GL_COLOR, 1, (GLint[]) { 32, glRenderer->target1Bd | (glRenderer->target2Bd * 2) | (glRenderer->blendEffect * 4), glRenderer->blda, 0 });
1428 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1429
1430 GBAVideoGLRendererDrawWindow(glRenderer, y);
1431 if (GBARegisterDISPCNTIsObjEnable(glRenderer->dispcnt) && !glRenderer->d.disableOBJ) {
1432 int i;
1433 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
1434 glEnable(GL_STENCIL_TEST);
1435 glDepthFunc(GL_LESS);
1436 for (i = 0; i < glRenderer->oamMax; ++i) {
1437 struct GBAVideoRendererSprite* sprite = &glRenderer->sprites[i];
1438 if ((y < sprite->y && (sprite->endY - 256 < 0 || glRenderer->firstY >= sprite->endY - 256)) || glRenderer->firstY >= sprite->endY) {
1439 continue;
1440 }
1441
1442 GBAVideoGLRendererDrawSprite(glRenderer, &sprite->obj, y, sprite->y);
1443 }
1444 glDisable(GL_DEPTH_TEST);
1445 glDisable(GL_STENCIL_TEST);
1446 }
1447
1448 if (TEST_LAYER_ENABLED(0) && GBARegisterDISPCNTGetMode(glRenderer->dispcnt) < 2) {
1449 GBAVideoGLRendererDrawBackgroundMode0(glRenderer, &glRenderer->bg[0], y);
1450 }
1451 if (TEST_LAYER_ENABLED(1) && GBARegisterDISPCNTGetMode(glRenderer->dispcnt) < 2) {
1452 GBAVideoGLRendererDrawBackgroundMode0(glRenderer, &glRenderer->bg[1], y);
1453 }
1454 if (TEST_LAYER_ENABLED(2)) {
1455 switch (GBARegisterDISPCNTGetMode(glRenderer->dispcnt)) {
1456 case 0:
1457 GBAVideoGLRendererDrawBackgroundMode0(glRenderer, &glRenderer->bg[2], y);
1458 break;
1459 case 1:
1460 case 2:
1461 GBAVideoGLRendererDrawBackgroundMode2(glRenderer, &glRenderer->bg[2], y);
1462 break;
1463 case 3:
1464 GBAVideoGLRendererDrawBackgroundMode3(glRenderer, &glRenderer->bg[2], y);
1465 break;
1466 case 4:
1467 GBAVideoGLRendererDrawBackgroundMode4(glRenderer, &glRenderer->bg[2], y);
1468 break;
1469 case 5:
1470 GBAVideoGLRendererDrawBackgroundMode5(glRenderer, &glRenderer->bg[2], y);
1471 break;
1472 }
1473 }
1474 if (TEST_LAYER_ENABLED(3)) {
1475 switch (GBARegisterDISPCNTGetMode(glRenderer->dispcnt)) {
1476 case 0:
1477 GBAVideoGLRendererDrawBackgroundMode0(glRenderer, &glRenderer->bg[3], y);
1478 break;
1479 case 2:
1480 GBAVideoGLRendererDrawBackgroundMode2(glRenderer, &glRenderer->bg[3], y);
1481 break;
1482 }
1483 }
1484 glRenderer->firstY = -1;
1485}
1486
1487void GBAVideoGLRendererFinishFrame(struct GBAVideoRenderer* renderer) {
1488 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
1489 _drawScanlines(glRenderer, GBA_VIDEO_VERTICAL_PIXELS - 1);
1490 _finalizeLayers(glRenderer);
1491 glDisable(GL_SCISSOR_TEST);
1492 glBindVertexArray(0);
1493 glRenderer->firstAffine = -1;
1494 glRenderer->firstY = -1;
1495 glRenderer->bg[2].affine.sx = glRenderer->bg[2].refx;
1496 glRenderer->bg[2].affine.sy = glRenderer->bg[2].refy;
1497 glRenderer->bg[3].affine.sx = glRenderer->bg[3].refx;
1498 glRenderer->bg[3].affine.sy = glRenderer->bg[3].refy;
1499}
1500
1501void GBAVideoGLRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels) {
1502 struct GBAVideoGLRenderer* glRenderer = (struct GBAVideoGLRenderer*) renderer;
1503 *stride = GBA_VIDEO_HORIZONTAL_PIXELS * glRenderer->scale;
1504 if (!glRenderer->temporaryBuffer) {
1505 glRenderer->temporaryBuffer = anonymousMemoryMap(GBA_VIDEO_HORIZONTAL_PIXELS * GBA_VIDEO_VERTICAL_PIXELS * glRenderer->scale * glRenderer->scale * BYTES_PER_PIXEL);
1506 }
1507 glFinish();
1508 glBindFramebuffer(GL_FRAMEBUFFER, glRenderer->fbo[GBA_GL_FBO_OUTPUT]);
1509 glPixelStorei(GL_PACK_ROW_LENGTH, GBA_VIDEO_HORIZONTAL_PIXELS * glRenderer->scale);
1510 glPixelStorei(GL_PACK_ALIGNMENT, 1);
1511 glReadPixels(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * glRenderer->scale, GBA_VIDEO_VERTICAL_PIXELS * glRenderer->scale, GL_RGBA, GL_UNSIGNED_BYTE, (void*) glRenderer->temporaryBuffer);
1512 *pixels = glRenderer->temporaryBuffer;
1513}
1514
1515void GBAVideoGLRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels) {
1516 // TODO
1517 UNUSED(renderer);
1518 UNUSED(stride);
1519 UNUSED(pixels);
1520}
1521
1522static void _enableBg(struct GBAVideoGLRenderer* renderer, int bg, bool active) {
1523 int wasActive = renderer->bg[bg].enabled;
1524 if (!active) {
1525 renderer->bg[bg].enabled = 0;
1526 } else if (!wasActive && active) {
1527 /*if (renderer->nextY == 0 || GBARegisterDISPCNTGetMode(renderer->dispcnt) > 2) {
1528 // TODO: Investigate in more depth how switching background works in different modes
1529 renderer->bg[bg].enabled = 4;
1530 } else {
1531 renderer->bg[bg].enabled = 1;
1532 }*/
1533 renderer->bg[bg].enabled = 4;
1534 }
1535}
1536
1537static void GBAVideoGLRendererUpdateDISPCNT(struct GBAVideoGLRenderer* renderer) {
1538 _enableBg(renderer, 0, GBARegisterDISPCNTGetBg0Enable(renderer->dispcnt));
1539 _enableBg(renderer, 1, GBARegisterDISPCNTGetBg1Enable(renderer->dispcnt));
1540 _enableBg(renderer, 2, GBARegisterDISPCNTGetBg2Enable(renderer->dispcnt));
1541 _enableBg(renderer, 3, GBARegisterDISPCNTGetBg3Enable(renderer->dispcnt));
1542}
1543
1544static void GBAVideoGLRendererWriteBGCNT(struct GBAVideoGLBackground* bg, uint16_t value) {
1545 bg->priority = GBARegisterBGCNTGetPriority(value);
1546 bg->charBase = GBARegisterBGCNTGetCharBase(value) << 13;
1547 bg->mosaic = GBARegisterBGCNTGetMosaic(value);
1548 bg->multipalette = GBARegisterBGCNTGet256Color(value);
1549 bg->screenBase = GBARegisterBGCNTGetScreenBase(value) << 10;
1550 bg->overflow = GBARegisterBGCNTGetOverflow(value);
1551 bg->size = GBARegisterBGCNTGetSize(value);
1552}
1553
1554static void GBAVideoGLRendererWriteBGX_LO(struct GBAVideoGLBackground* bg, uint16_t value) {
1555 bg->refx = (bg->refx & 0xFFFF0000) | value;
1556 bg->affine.sx = bg->refx;
1557}
1558
1559static void GBAVideoGLRendererWriteBGX_HI(struct GBAVideoGLBackground* bg, uint16_t value) {
1560 bg->refx = (bg->refx & 0x0000FFFF) | (value << 16);
1561 bg->refx <<= 4;
1562 bg->refx >>= 4;
1563 bg->affine.sx = bg->refx;
1564}
1565
1566static void GBAVideoGLRendererWriteBGY_LO(struct GBAVideoGLBackground* bg, uint16_t value) {
1567 bg->refy = (bg->refy & 0xFFFF0000) | value;
1568 bg->affine.sy = bg->refy;
1569}
1570
1571static void GBAVideoGLRendererWriteBGY_HI(struct GBAVideoGLBackground* bg, uint16_t value) {
1572 bg->refy = (bg->refy & 0x0000FFFF) | (value << 16);
1573 bg->refy <<= 4;
1574 bg->refy >>= 4;
1575 bg->affine.sy = bg->refy;
1576}
1577
1578static void GBAVideoGLRendererWriteBLDCNT(struct GBAVideoGLRenderer* renderer, uint16_t value) {
1579 renderer->bg[0].target1 = GBARegisterBLDCNTGetTarget1Bg0(value);
1580 renderer->bg[1].target1 = GBARegisterBLDCNTGetTarget1Bg1(value);
1581 renderer->bg[2].target1 = GBARegisterBLDCNTGetTarget1Bg2(value);
1582 renderer->bg[3].target1 = GBARegisterBLDCNTGetTarget1Bg3(value);
1583 renderer->bg[0].target2 = GBARegisterBLDCNTGetTarget2Bg0(value);
1584 renderer->bg[1].target2 = GBARegisterBLDCNTGetTarget2Bg1(value);
1585 renderer->bg[2].target2 = GBARegisterBLDCNTGetTarget2Bg2(value);
1586 renderer->bg[3].target2 = GBARegisterBLDCNTGetTarget2Bg3(value);
1587
1588 renderer->blendEffect = GBARegisterBLDCNTGetEffect(value);
1589 renderer->target1Obj = GBARegisterBLDCNTGetTarget1Obj(value);
1590 renderer->target1Bd = GBARegisterBLDCNTGetTarget1Bd(value);
1591 renderer->target2Obj = GBARegisterBLDCNTGetTarget2Obj(value);
1592 renderer->target2Bd = GBARegisterBLDCNTGetTarget2Bd(value);
1593}
1594
1595void _finalizeLayers(struct GBAVideoGLRenderer* renderer) {
1596 const GLuint* uniforms = renderer->finalizeShader.uniforms;
1597 glBindFramebuffer(GL_FRAMEBUFFER, renderer->fbo[GBA_GL_FBO_OUTPUT]);
1598 glViewport(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1599 glScissor(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1600 if (GBARegisterDISPCNTIsForcedBlank(renderer->dispcnt)) {
1601 glClearColor(1.f, 1.f, 1.f, 1.f);
1602 glClear(GL_COLOR_BUFFER_BIT);
1603 } else {
1604 glUseProgram(renderer->finalizeShader.program);
1605 glBindVertexArray(renderer->finalizeShader.vao);
1606 glActiveTexture(GL_TEXTURE0);
1607 glBindTexture(GL_TEXTURE_2D, renderer->layers[GBA_GL_TEX_WINDOW]);
1608 glActiveTexture(GL_TEXTURE0 + 1);
1609 glBindTexture(GL_TEXTURE_2D, renderer->layers[GBA_GL_TEX_OBJ_COLOR]);
1610 glActiveTexture(GL_TEXTURE0 + 2);
1611 glBindTexture(GL_TEXTURE_2D, renderer->layers[GBA_GL_TEX_OBJ_FLAGS]);
1612 glActiveTexture(GL_TEXTURE0 + 3);
1613 glBindTexture(GL_TEXTURE_2D, renderer->bg[0].tex);
1614 glActiveTexture(GL_TEXTURE0 + 4);
1615 glBindTexture(GL_TEXTURE_2D, renderer->bg[0].flags);
1616 glActiveTexture(GL_TEXTURE0 + 5);
1617 glBindTexture(GL_TEXTURE_2D, renderer->bg[1].tex);
1618 glActiveTexture(GL_TEXTURE0 + 6);
1619 glBindTexture(GL_TEXTURE_2D, renderer->bg[1].flags);
1620 glActiveTexture(GL_TEXTURE0 + 7);
1621 glBindTexture(GL_TEXTURE_2D, renderer->bg[2].tex);
1622 glActiveTexture(GL_TEXTURE0 + 8);
1623 glBindTexture(GL_TEXTURE_2D, renderer->bg[2].flags);
1624 glActiveTexture(GL_TEXTURE0 + 9);
1625 glBindTexture(GL_TEXTURE_2D, renderer->bg[3].tex);
1626 glActiveTexture(GL_TEXTURE0 + 10);
1627 glBindTexture(GL_TEXTURE_2D, renderer->bg[3].flags);
1628 glActiveTexture(GL_TEXTURE0 + 11);
1629 glBindTexture(GL_TEXTURE_2D, renderer->layers[GBA_GL_TEX_BACKDROP_COLOR]);
1630 glActiveTexture(GL_TEXTURE0 + 12);
1631 glBindTexture(GL_TEXTURE_2D, renderer->layers[GBA_GL_TEX_BACKDROP_FLAGS]);
1632
1633 glUniform2i(uniforms[GBA_GL_VS_LOC], GBA_VIDEO_VERTICAL_PIXELS, 0);
1634 glUniform2i(uniforms[GBA_GL_VS_MAXPOS], GBA_VIDEO_HORIZONTAL_PIXELS, GBA_VIDEO_VERTICAL_PIXELS);
1635 glUniform1i(uniforms[GBA_GL_FINALIZE_SCALE], renderer->scale);
1636 glUniform1iv(uniforms[GBA_GL_FINALIZE_LAYERS], 5, (GLint[]) { 3, 5, 7, 9, 1 });
1637 glUniform1iv(uniforms[GBA_GL_FINALIZE_FLAGS], 5, (GLint[]) { 4, 6, 8, 10, 2 });
1638 glUniform1i(uniforms[GBA_GL_FINALIZE_WINDOW], 0);
1639 glUniform1i(uniforms[GBA_GL_FINALIZE_WINDOW], 0);
1640 glUniform1i(uniforms[GBA_GL_FINALIZE_BACKDROP], 11);
1641 glUniform1i(uniforms[GBA_GL_FINALIZE_BACKDROPFLAGS], 12);
1642 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1643 }
1644 glBindFramebuffer(GL_FRAMEBUFFER, 0);
1645}
1646
1647void GBAVideoGLRendererDrawSprite(struct GBAVideoGLRenderer* renderer, struct GBAObj* sprite, int y, int spriteY) {
1648 int width = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][0];
1649 int height = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][1];
1650 int32_t x = (uint32_t) GBAObjAttributesBGetX(sprite->b) << 23;
1651 x >>= 23;
1652
1653 if (GBARegisterDISPCNTGetMode(renderer->dispcnt) >= 3 && GBAObjAttributesCGetTile(sprite->c) < 512) {
1654 return;
1655 }
1656
1657 int align = GBAObjAttributesAIs256Color(sprite->a) && !GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt);
1658 unsigned charBase = (BASE_TILE >> 1) + (GBAObjAttributesCGetTile(sprite->c) & ~align) * 0x10;
1659 int stride = GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt) ? (width >> 3) : (0x20 >> GBAObjAttributesAGet256Color(sprite->a));
1660
1661 int totalWidth = width;
1662 int totalHeight = height;
1663 if (GBAObjAttributesAIsTransformed(sprite->a) && GBAObjAttributesAIsDoubleSize(sprite->a)) {
1664 totalWidth <<= 1;
1665 totalHeight <<= 1;
1666 }
1667
1668 if (spriteY + totalHeight >= 256) {
1669 spriteY -= 256;
1670 }
1671
1672 const struct GBAVideoGLShader* shader = &renderer->objShader[GBAObjAttributesAGet256Color(sprite->a)];
1673 const GLuint* uniforms = shader->uniforms;
1674 glBindFramebuffer(GL_FRAMEBUFFER, renderer->fbo[GBA_GL_FBO_OBJ]);
1675 glViewport(x * renderer->scale, spriteY * renderer->scale, totalWidth * renderer->scale, totalHeight * renderer->scale);
1676 glScissor(x * renderer->scale, renderer->firstY * renderer->scale, totalWidth * renderer->scale, (y - renderer->firstY + 1) * renderer->scale);
1677 glUseProgram(shader->program);
1678 glBindVertexArray(shader->vao);
1679 glActiveTexture(GL_TEXTURE0);
1680 glBindTexture(GL_TEXTURE_2D, renderer->vramTex);
1681 glUniform2i(uniforms[GBA_GL_VS_LOC], totalHeight, 0);
1682 glUniform2i(uniforms[GBA_GL_VS_MAXPOS], totalWidth, totalHeight);
1683 glUniform1i(uniforms[GBA_GL_OBJ_VRAM], 0);
1684 glUniform1iv(uniforms[GBA_GL_OBJ_PALETTE], 256, &renderer->shadowPalette[256]);
1685 glUniform1i(uniforms[GBA_GL_OBJ_CHARBASE], charBase);
1686 glUniform1i(uniforms[GBA_GL_OBJ_STRIDE], stride);
1687 glUniform1i(uniforms[GBA_GL_OBJ_LOCALPALETTE], GBAObjAttributesCGetPalette(sprite->c));
1688 glUniform4i(uniforms[GBA_GL_OBJ_INFLAGS], GBAObjAttributesCGetPriority(sprite->c),
1689 (renderer->target1Obj || GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT) | (renderer->target2Obj * 2) | (renderer->blendEffect * 4),
1690 renderer->blda, GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT);
1691 if (GBAObjAttributesAIsTransformed(sprite->a)) {
1692 struct GBAOAMMatrix mat;
1693 LOAD_16(mat.a, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].a);
1694 LOAD_16(mat.b, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].b);
1695 LOAD_16(mat.c, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].c);
1696 LOAD_16(mat.d, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].d);
1697
1698 glUniformMatrix2fv(uniforms[GBA_GL_OBJ_TRANSFORM], 1, GL_FALSE, (GLfloat[]) { mat.a / 256.f, mat.c / 256.f, mat.b / 256.f, mat.d / 256.f });
1699 } else {
1700 int flipX = 1;
1701 int flipY = 1;
1702 if (GBAObjAttributesBIsHFlip(sprite->b)) {
1703 flipX = -1;
1704 }
1705 if (GBAObjAttributesBIsVFlip(sprite->b)) {
1706 flipY = -1;
1707 }
1708 glUniformMatrix2fv(uniforms[GBA_GL_OBJ_TRANSFORM], 1, GL_FALSE, (GLfloat[]) { flipX, 0, 0, flipY });
1709 }
1710 glUniform4i(uniforms[GBA_GL_OBJ_DIMS], width, height, totalWidth, totalHeight);
1711 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_OBJWIN) {
1712 // OBJWIN writes do not affect pixel priority
1713 glDisable(GL_DEPTH_TEST);
1714 glDepthMask(GL_FALSE);
1715 glStencilMask(GL_FALSE);
1716 int window = renderer->objwin & 0x3F;
1717 glUniform4i(uniforms[GBA_GL_OBJ_OBJWIN], 1, window, renderer->bldb, renderer->bldy);
1718 glDrawBuffers(3, (GLenum[]) { GL_NONE, GL_NONE, GL_COLOR_ATTACHMENT2 });
1719 } else {
1720 glEnable(GL_DEPTH_TEST);
1721 glDepthMask(GL_TRUE);
1722 glStencilMask(GL_TRUE);
1723 glStencilFunc(GL_ALWAYS, 1, 1);
1724 glUniform4i(uniforms[GBA_GL_OBJ_OBJWIN], 0, 0, 0, 0);
1725 glDrawBuffers(2, (GLenum[]) { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 });
1726 }
1727 if (GBAObjAttributesAIsMosaic(sprite->a) && GBAObjAttributesAGetMode(sprite->a) != OBJ_MODE_OBJWIN) {
1728 int mosaicH = GBAMosaicControlGetObjH(renderer->mosaic) + 1;
1729 if (GBAObjAttributesBIsHFlip(sprite->b)) {
1730 mosaicH = -mosaicH;
1731 }
1732 glUniform4i(uniforms[GBA_GL_OBJ_MOSAIC], mosaicH, GBAMosaicControlGetObjV(renderer->mosaic) + 1, x, spriteY);
1733 } else {
1734 glUniform4i(uniforms[GBA_GL_OBJ_MOSAIC], 0, 0, 0, 0);
1735 }
1736 if (GBAObjAttributesAGetMode(sprite->a) != OBJ_MODE_OBJWIN || GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt)) {
1737 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1738 }
1739
1740 if (GBAObjAttributesAGetMode(sprite->a) != OBJ_MODE_OBJWIN) {
1741 // Update the pixel priority for already-written pixels
1742 shader = &renderer->objShader[2];
1743 uniforms = shader->uniforms;
1744 glStencilFunc(GL_EQUAL, 1, 1);
1745 glUseProgram(shader->program);
1746 glDrawBuffers(2, (GLenum[]) { GL_NONE, GL_COLOR_ATTACHMENT1 });
1747 glBindVertexArray(shader->vao);
1748 glUniform2i(uniforms[GBA_GL_VS_LOC], totalHeight, 0);
1749 glUniform2i(uniforms[GBA_GL_VS_MAXPOS], totalWidth, totalHeight);
1750 glUniform4i(uniforms[GBA_GL_OBJ_INFLAGS], GBAObjAttributesCGetPriority(sprite->c),
1751 (renderer->target1Obj || GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT) | (renderer->target2Obj * 2) | (renderer->blendEffect * 4),
1752 renderer->blda, GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT);
1753 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1754 }
1755
1756 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1757}
1758
1759void _prepareBackground(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, const GLuint* uniforms) {
1760 glBindFramebuffer(GL_FRAMEBUFFER, background->fbo);
1761 glViewport(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1762 glActiveTexture(GL_TEXTURE0);
1763 glBindTexture(GL_TEXTURE_2D, renderer->vramTex);
1764 glUniform2i(uniforms[GBA_GL_VS_MAXPOS], GBA_VIDEO_HORIZONTAL_PIXELS, GBA_VIDEO_VERTICAL_PIXELS);
1765 glUniform1i(uniforms[GBA_GL_BG_VRAM], 0);
1766 glUniform1iv(uniforms[GBA_GL_OBJ_PALETTE], 256, renderer->shadowPalette);
1767 if (background->mosaic) {
1768 glUniform2i(uniforms[GBA_GL_BG_MOSAIC], GBAMosaicControlGetBgV(renderer->mosaic) + 1, GBAMosaicControlGetBgH(renderer->mosaic) + 1);
1769 } else {
1770 glUniform2i(uniforms[GBA_GL_BG_MOSAIC], 0, 0);
1771 }
1772 glUniform4i(uniforms[GBA_GL_BG_INFLAGS], background->priority,
1773 background->target1 | (background->target2 * 2) | (renderer->blendEffect * 4),
1774 renderer->blda, 0);
1775 glDrawBuffers(2, (GLenum[]) { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 });
1776}
1777
1778void GBAVideoGLRendererDrawBackgroundMode0(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1779 const struct GBAVideoGLShader* shader = &renderer->bgShader[background->multipalette ? 1 : 0];
1780 const GLuint* uniforms = shader->uniforms;
1781 glUseProgram(shader->program);
1782 glBindVertexArray(shader->vao);
1783 _prepareBackground(renderer, background, uniforms);
1784 glUniform1i(uniforms[GBA_GL_BG_SCREENBASE], background->screenBase);
1785 glUniform1i(uniforms[GBA_GL_BG_CHARBASE], background->charBase);
1786 glUniform1i(uniforms[GBA_GL_BG_SIZE], background->size);
1787 glUniform1iv(uniforms[GBA_GL_BG_OFFSET], GBA_VIDEO_VERTICAL_PIXELS, background->scanlineOffset);
1788
1789 glScissor(0, renderer->firstY * renderer->scale, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, (y - renderer->firstY + 1) * renderer->scale);
1790 glUniform2i(uniforms[GBA_GL_VS_LOC], y - renderer->firstY + 1, renderer->firstY);
1791 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1792
1793 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1794}
1795
1796void _prepareTransform(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, const GLuint* uniforms, int y) {
1797 glScissor(0, renderer->firstY * renderer->scale, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, renderer->scale * (y - renderer->firstY + 1));
1798 glUniform2i(uniforms[GBA_GL_VS_LOC], y - renderer->firstY + 1, renderer->firstY);
1799 glUniform2i(uniforms[GBA_GL_BG_RANGE], renderer->firstAffine, y);
1800
1801 glUniform4iv(uniforms[GBA_GL_BG_TRANSFORM], GBA_VIDEO_VERTICAL_PIXELS, background->scanlineAffine);
1802 _prepareBackground(renderer, background, uniforms);
1803}
1804
1805void GBAVideoGLRendererDrawBackgroundMode2(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1806 const struct GBAVideoGLShader* shader = &renderer->bgShader[background->overflow ? 2 : 3];
1807 const GLuint* uniforms = shader->uniforms;
1808 glUseProgram(shader->program);
1809 glBindVertexArray(shader->vao);
1810 _prepareTransform(renderer, background, uniforms, y);
1811 glUniform1i(uniforms[GBA_GL_BG_SCREENBASE], background->screenBase);
1812 glUniform1i(uniforms[GBA_GL_BG_CHARBASE], background->charBase);
1813 glUniform1i(uniforms[GBA_GL_BG_SIZE], background->size);
1814 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1815 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1816}
1817
1818void GBAVideoGLRendererDrawBackgroundMode3(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1819 const struct GBAVideoGLShader* shader = &renderer->bgShader[5];
1820 const GLuint* uniforms = shader->uniforms;
1821 glBindFramebuffer(GL_FRAMEBUFFER, background->fbo);
1822 glViewport(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1823 glUseProgram(shader->program);
1824 glBindVertexArray(shader->vao);
1825 _prepareTransform(renderer, background, uniforms, y);
1826 glUniform1i(uniforms[GBA_GL_BG_CHARBASE], 0);
1827 glUniform2i(uniforms[GBA_GL_BG_SIZE], GBA_VIDEO_HORIZONTAL_PIXELS, GBA_VIDEO_VERTICAL_PIXELS);
1828 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1829 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1830}
1831
1832void GBAVideoGLRendererDrawBackgroundMode4(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1833 const struct GBAVideoGLShader* shader = &renderer->bgShader[4];
1834 const GLuint* uniforms = shader->uniforms;
1835 glBindFramebuffer(GL_FRAMEBUFFER, background->fbo);
1836 glViewport(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1837 glUseProgram(shader->program);
1838 glBindVertexArray(shader->vao);
1839 _prepareTransform(renderer, background, uniforms, y);
1840 glUniform1i(uniforms[GBA_GL_BG_CHARBASE], GBARegisterDISPCNTIsFrameSelect(renderer->dispcnt) ? 0xA000 : 0);
1841 glUniform2i(uniforms[GBA_GL_BG_SIZE], GBA_VIDEO_HORIZONTAL_PIXELS, GBA_VIDEO_VERTICAL_PIXELS);
1842 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1843 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1844}
1845
1846void GBAVideoGLRendererDrawBackgroundMode5(struct GBAVideoGLRenderer* renderer, struct GBAVideoGLBackground* background, int y) {
1847 const struct GBAVideoGLShader* shader = &renderer->bgShader[5];
1848 const GLuint* uniforms = shader->uniforms;
1849 glBindFramebuffer(GL_FRAMEBUFFER, background->fbo);
1850 glViewport(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1851 glUseProgram(shader->program);
1852 glBindVertexArray(shader->vao);
1853 _prepareTransform(renderer, background, uniforms, y);
1854 glUniform1i(uniforms[GBA_GL_BG_CHARBASE], GBARegisterDISPCNTIsFrameSelect(renderer->dispcnt) ? 0x5000 : 0);
1855 glUniform2i(uniforms[GBA_GL_BG_SIZE], 160, 128);
1856 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1857 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1858}
1859
1860void GBAVideoGLRendererDrawWindow(struct GBAVideoGLRenderer* renderer, int y) {
1861 const struct GBAVideoGLShader* shader = &renderer->windowShader;
1862 const GLuint* uniforms = shader->uniforms;
1863 glBindFramebuffer(GL_FRAMEBUFFER, renderer->fbo[GBA_GL_FBO_WINDOW]);
1864 glViewport(0, 0, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, GBA_VIDEO_VERTICAL_PIXELS * renderer->scale);
1865 glScissor(0, renderer->firstY * renderer->scale, GBA_VIDEO_HORIZONTAL_PIXELS * renderer->scale, renderer->scale * (y - renderer->firstY + 1));
1866 glUseProgram(shader->program);
1867 glBindVertexArray(shader->vao);
1868 glUniform2i(uniforms[GBA_GL_VS_LOC], y - renderer->firstY + 1, renderer->firstY);
1869 glUniform2i(uniforms[GBA_GL_VS_MAXPOS], GBA_VIDEO_HORIZONTAL_PIXELS, GBA_VIDEO_VERTICAL_PIXELS);
1870 glUniform1i(uniforms[GBA_GL_WIN_DISPCNT], renderer->dispcnt >> 8);
1871 glUniform2i(uniforms[GBA_GL_WIN_BLEND], renderer->bldb, renderer->bldy);
1872 glUniform3i(uniforms[GBA_GL_WIN_FLAGS], renderer->winN[0].control, renderer->winN[1].control, renderer->winout);
1873 glUniform4iv(uniforms[GBA_GL_WIN_WIN0], GBA_VIDEO_VERTICAL_PIXELS, renderer->winNHistory[0]);
1874 glUniform4iv(uniforms[GBA_GL_WIN_WIN1], GBA_VIDEO_VERTICAL_PIXELS, renderer->winNHistory[1]);
1875 glDrawBuffers(1, (GLenum[]) { GL_COLOR_ATTACHMENT0 });
1876 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1877}
1878
1879void GBAVideoGLRendererSetScale(struct GBAVideoGLRenderer* renderer, int scale) {
1880 if (scale == renderer->scale) {
1881 return;
1882 }
1883 if (renderer->temporaryBuffer) {
1884 mappedMemoryFree(renderer->temporaryBuffer, GBA_VIDEO_HORIZONTAL_PIXELS * GBA_VIDEO_VERTICAL_PIXELS * renderer->scale * renderer->scale * BYTES_PER_PIXEL);
1885 renderer->temporaryBuffer = NULL;
1886 }
1887 renderer->scale = scale;
1888 _initFramebuffers(renderer);
1889 renderer->paletteDirty = true;
1890}
1891
1892#endif