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