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