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